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

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

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

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

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

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

26 files changed, 1477 insertions, 2025 deletions

diff --git a/source/gameengine/Rasterizer/Makefile b/source/gameengine/Rasterizer/Makefile
index e3b1f274ee5..917f70c7108 100644
--- a/source/gameengine/Rasterizer/Makefile
+++ b/source/gameengine/Rasterizer/Makefile
@@ -49,10 +49,6 @@ ifeq ($(OS),darwin)
 	CPPFLAGS += -fpascal-strings
 endif
 
-ifeq ($(WITH_BF_GLEXT),true)
-    CPPFLAGS += -DWITH_GLEXT
-endif
-
 ###############
 
 SOURCEDIR = source/gameengine/Rasterizer
diff --git a/source/gameengine/Rasterizer/RAS_BucketManager.cpp b/source/gameengine/Rasterizer/RAS_BucketManager.cpp
index 82bdce44519..9fb21a3c17b 100644
--- a/source/gameengine/Rasterizer/RAS_BucketManager.cpp
+++ b/source/gameengine/Rasterizer/RAS_BucketManager.cpp
@@ -26,10 +26,6 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #ifdef WIN32
 // don't show these anoying STL warnings
 #pragma warning (disable:4786)
@@ -39,168 +35,243 @@
 #include "RAS_MaterialBucket.h"
 #include "STR_HashedString.h"
 #include "RAS_MeshObject.h"
-#define KX_NUM_MATERIALBUCKETS 100
 #include "RAS_IRasterizer.h"
 #include "RAS_IRenderTools.h"
 
 #include "RAS_BucketManager.h"
 
+#include <algorithm>
 #include <set>
 
-RAS_BucketManager::RAS_BucketManager()
+/* sorting */
+
+struct RAS_BucketManager::sortedmeshslot
 {
+public:
+	MT_Scalar m_z;					/* depth */
+	RAS_MeshSlot *m_ms;				/* mesh slot */
+	RAS_MaterialBucket *m_bucket;	/* buck mesh slot came from */
 
-}
+	sortedmeshslot() {}
 
-RAS_BucketManager::~RAS_BucketManager()
-{
-		RAS_BucketManagerClearAll();
-}
+	void set(RAS_MeshSlot *ms, RAS_MaterialBucket *bucket, const MT_Vector3& pnorm)
+	{
+		// would be good to use the actual bounding box center instead
+		MT_Point3 pos(ms->m_OpenGLMatrix[12], ms->m_OpenGLMatrix[13], ms->m_OpenGLMatrix[14]);
 
-/**
- * struct alphamesh holds a mesh, (m_ms) it's depth, (m_z) and the bucket it came from (m_bucket.)
- */
-struct RAS_BucketManager::alphamesh
-{
-public:
-	MT_Scalar m_z;
-	RAS_MaterialBucket::T_MeshSlotList::iterator m_ms;
-	RAS_MaterialBucket *m_bucket;
-	alphamesh(MT_Scalar z, RAS_MaterialBucket::T_MeshSlotList::iterator &ms, RAS_MaterialBucket *bucket) :
-		m_z(z),
-		m_ms(ms),
-		m_bucket(bucket)
-	{}
+		m_z = MT_dot(pnorm, pos);
+		m_ms = ms;
+		m_bucket = bucket;
+	}
 };
 
 struct RAS_BucketManager::backtofront
 {
-	bool operator()(const alphamesh &a, const alphamesh &b)
+	bool operator()(const sortedmeshslot &a, const sortedmeshslot &b)
 	{
-		return a.m_z < b.m_z;
+		return (a.m_z < b.m_z) || (a.m_z == b.m_z && a.m_ms < b.m_ms);
 	}
 };
+
+struct RAS_BucketManager::fronttoback
+{
+	bool operator()(const sortedmeshslot &a, const sortedmeshslot &b)
+	{
+		return (a.m_z > b.m_z) || (a.m_z == b.m_z && a.m_ms > b.m_ms);
+	}
+};
+
+/* bucket manager */
+
+RAS_BucketManager::RAS_BucketManager()
+{
+
+}
+
+RAS_BucketManager::~RAS_BucketManager()
+{
+	BucketList::iterator it;
+
+	for (it = m_SolidBuckets.begin(); it != m_SolidBuckets.end(); it++)
+		delete (*it);
+
+	for (it = m_AlphaBuckets.begin(); it != m_AlphaBuckets.end(); it++)
+		delete(*it);
 	
+	m_SolidBuckets.clear();
+	m_AlphaBuckets.clear();
+}
+
+void RAS_BucketManager::OrderBuckets(const MT_Transform& cameratrans, BucketList& buckets, vector<sortedmeshslot>& slots, bool alpha)
+{
+	BucketList::iterator bit;
+	list<RAS_MeshSlot>::iterator mit;
+	size_t size = 0, i = 0;
+
+	/* Camera's near plane equation: pnorm.dot(point) + pval,
+	 * but we leave out pval since it's constant anyway */
+	const MT_Vector3 pnorm(cameratrans.getBasis()[2]);
+
+	for (bit = buckets.begin(); bit != buckets.end(); ++bit)
+		for (mit = (*bit)->msBegin(); mit != (*bit)->msEnd(); ++mit)
+			if (!mit->IsCulled())
+				size++;
+
+	slots.resize(size);
+
+	for (bit = buckets.begin(); bit != buckets.end(); ++bit)
+		for (mit = (*bit)->msBegin(); mit != (*bit)->msEnd(); ++mit)
+			if (!mit->IsCulled())
+				slots[i++].set(&*mit, *bit, pnorm);
+		
+	if(alpha)
+		sort(slots.begin(), slots.end(), backtofront());
+	else
+		sort(slots.begin(), slots.end(), fronttoback());
+}
+
+//static int TOTASLOT = 0;
+//static int TOTSLOT = 0;
 
 void RAS_BucketManager::RenderAlphaBuckets(
 	const MT_Transform& cameratrans, RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools)
 {
-	BucketList::iterator bit;
-	std::multiset<alphamesh, backtofront> alphameshset;
-	RAS_MaterialBucket::T_MeshSlotList::iterator mit;
+	vector<sortedmeshslot> slots;
+	vector<sortedmeshslot>::iterator sit;
+
+	// Having depth masks disabled/enabled gives different artifacts in
+	// case no sorting is done or is done inexact. For compatibility, we
+	// disable it.
+	rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_DISABLED);
+
+	OrderBuckets(cameratrans, m_AlphaBuckets, slots, true);
 	
-	/* Camera's near plane equation: cam_norm.dot(point) + cam_origin */
-	const MT_Vector3 cam_norm(cameratrans.getBasis()[2]);
-	const MT_Scalar cam_origin = cameratrans.getOrigin()[2];
-	for (bit = m_AlphaBuckets.begin(); bit != m_AlphaBuckets.end(); ++bit)
-	{
-		for (mit = (*bit)->msBegin(); mit != (*bit)->msEnd(); ++mit)
-		{
-			if ((*mit).m_bVisible)
-			{
-				MT_Point3 pos((*mit).m_OpenGLMatrix[12], (*mit).m_OpenGLMatrix[13], (*mit).m_OpenGLMatrix[14]);
-				alphameshset.insert(alphamesh(MT_dot(cam_norm, pos) + cam_origin, mit, *bit));
+	for(sit=slots.begin(); sit!=slots.end(); ++sit) {
+		rendertools->SetClientObject(rasty, sit->m_ms->m_clientObj);
+
+		while(sit->m_bucket->ActivateMaterial(cameratrans, rasty, rendertools)) {
+			sit->m_bucket->RenderMeshSlot(cameratrans, rasty, rendertools, *(sit->m_ms));
+			//TOTASLOT++;
+		}
+	}
+
+	rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_ENABLED);
+}
+
+void RAS_BucketManager::RenderSolidBuckets(
+	const MT_Transform& cameratrans, RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools)
+{
+	BucketList::iterator bit;
+	list<RAS_MeshSlot>::iterator mit;
+
+	rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_ENABLED);
+
+	for (bit = m_SolidBuckets.begin(); bit != m_SolidBuckets.end(); ++bit) {
+		for (mit = (*bit)->msBegin(); mit != (*bit)->msEnd(); ++mit) {
+			if (mit->IsCulled())
+				continue;
+
+			rendertools->SetClientObject(rasty, mit->m_clientObj);
+
+			while ((*bit)->ActivateMaterial(cameratrans, rasty, rendertools)) {
+				(*bit)->RenderMeshSlot(cameratrans, rasty, rendertools, *mit);
+				//TOTSLOT++;
 			}
 		}
 	}
 	
-	// It shouldn't be strictly necessary to disable depth writes; but
-	// it is needed for compatibility.
-	rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_DISABLED);
+#if 0
+	vector<sortedmeshslot> slots;
+	vector<sortedmeshslot>::iterator sit;
 
-	RAS_IRasterizer::DrawMode drawingmode;
-	std::multiset< alphamesh, backtofront>::iterator msit = alphameshset.begin();
-	for (; msit != alphameshset.end(); ++msit)
-	{
-		rendertools->SetClientObject((*(*msit).m_ms).m_clientObj);
-		while ((*msit).m_bucket->ActivateMaterial(cameratrans, rasty, rendertools, drawingmode))
-			(*msit).m_bucket->RenderMeshSlot(cameratrans, rasty, rendertools, *(*msit).m_ms, drawingmode);
+	OrderBuckets(cameratrans, m_SolidBuckets, slots, false);
+
+	for(sit=slots.begin(); sit!=slots.end(); ++sit) {
+		rendertools->SetClientObject(rasty, sit->m_ms->m_clientObj);
+
+		while(sit->m_bucket->ActivateMaterial(cameratrans, rasty, rendertools))
+			sit->m_bucket->RenderMeshSlot(cameratrans, rasty, rendertools, *(sit->m_ms));
 	}
-	
-	rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_ENABLED);
+#endif
 }
 
 void RAS_BucketManager::Renderbuckets(
 	const MT_Transform& cameratrans, RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools)
 {
-	BucketList::iterator bucket;
-	
-	rasty->EnableTextures(false);
-	rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_ENABLED);
-	
 	// beginning each frame, clear (texture/material) caching information
 	rasty->ClearCachingInfo();
 
-	RAS_MaterialBucket::StartFrame();
-	
-	for (bucket = m_MaterialBuckets.begin(); bucket != m_MaterialBuckets.end(); ++bucket)
-		(*bucket)->Render(cameratrans,rasty,rendertools);
+	//TOTASLOT = 0;
+	//TOTSLOT = 0;
 
+	RenderSolidBuckets(cameratrans, rasty, rendertools);	
 	RenderAlphaBuckets(cameratrans, rasty, rendertools);	
-	RAS_MaterialBucket::EndFrame();
+
+	//printf("total slots = %d = %d + %d\n", TOTSLOT + TOTASLOT, TOTSLOT, TOTASLOT);
+
+	rendertools->SetClientObject(rasty, NULL);
 }
 
 RAS_MaterialBucket* RAS_BucketManager::FindBucket(RAS_IPolyMaterial * material, bool &bucketCreated)
 {
-	bucketCreated = false;
 	BucketList::iterator it;
-	for (it = m_MaterialBuckets.begin(); it != m_MaterialBuckets.end(); it++)
-	{
+
+	bucketCreated = false;
+
+	for (it = m_SolidBuckets.begin(); it != m_SolidBuckets.end(); it++)
 		if (*(*it)->GetPolyMaterial() == *material)
 			return *it;
-	}
 	
 	for (it = m_AlphaBuckets.begin(); it != m_AlphaBuckets.end(); it++)
-	{
 		if (*(*it)->GetPolyMaterial() == *material)
 			return *it;
-	}
 	
 	RAS_MaterialBucket *bucket = new RAS_MaterialBucket(material);
 	bucketCreated = true;
+
 	if (bucket->IsAlpha())
 		m_AlphaBuckets.push_back(bucket);
 	else
-		m_MaterialBuckets.push_back(bucket);
+		m_SolidBuckets.push_back(bucket);
 	
 	return bucket;
 }
 
-void RAS_BucketManager::RAS_BucketManagerClearAll()
+void RAS_BucketManager::OptimizeBuckets(MT_Scalar distance)
 {
-	BucketList::iterator it;
-	for (it = m_MaterialBuckets.begin(); it != m_MaterialBuckets.end(); it++)
-	{
-		delete (*it);
-	}
-	for (it = m_AlphaBuckets.begin(); it != m_AlphaBuckets.end(); it++)
-	{
-		delete(*it);
-	}
+	BucketList::iterator bit;
 	
-	m_MaterialBuckets.clear();
-	m_AlphaBuckets.clear();
+	distance = 10.0;
+
+	for (bit = m_SolidBuckets.begin(); bit != m_SolidBuckets.end(); ++bit)
+		(*bit)->Optimize(distance);
+	for (bit = m_AlphaBuckets.begin(); bit != m_AlphaBuckets.end(); ++bit)
+		(*bit)->Optimize(distance);
 }
 
-void RAS_BucketManager::ReleaseDisplayLists()
+void RAS_BucketManager::ReleaseDisplayLists(RAS_IPolyMaterial *mat)
 {
 	BucketList::iterator bit;
-	RAS_MaterialBucket::T_MeshSlotList::iterator mit;
+	list<RAS_MeshSlot>::iterator mit;
 
-	for (bit = m_MaterialBuckets.begin(); bit != m_MaterialBuckets.end(); ++bit) {
-		for (mit = (*bit)->msBegin(); mit != (*bit)->msEnd(); ++mit) {
-			if(mit->m_DisplayList) {
-				mit->m_DisplayList->Release();
-				mit->m_DisplayList = NULL;
+	for (bit = m_SolidBuckets.begin(); bit != m_SolidBuckets.end(); ++bit) {
+		if (mat == NULL || (mat == (*bit)->GetPolyMaterial())) {
+			for (mit = (*bit)->msBegin(); mit != (*bit)->msEnd(); ++mit) {
+				if(mit->m_DisplayList) {
+					mit->m_DisplayList->Release();
+					mit->m_DisplayList = NULL;
+				}
 			}
 		}
 	}
 	
 	for (bit = m_AlphaBuckets.begin(); bit != m_AlphaBuckets.end(); ++bit) {
-		for (mit = (*bit)->msBegin(); mit != (*bit)->msEnd(); ++mit) {
-			if(mit->m_DisplayList) {
-				mit->m_DisplayList->Release();
-				mit->m_DisplayList = NULL;
+		if (mat == NULL || (mat == (*bit)->GetPolyMaterial())) {
+			for (mit = (*bit)->msBegin(); mit != (*bit)->msEnd(); ++mit) {
+				if(mit->m_DisplayList) {
+					mit->m_DisplayList->Release();
+					mit->m_DisplayList = NULL;
+				}
 			}
 		}
 	}
diff --git a/source/gameengine/Rasterizer/RAS_BucketManager.h b/source/gameengine/Rasterizer/RAS_BucketManager.h
index 08b67ed022f..74526f365a0 100644
--- a/source/gameengine/Rasterizer/RAS_BucketManager.h
+++ b/source/gameengine/Rasterizer/RAS_BucketManager.h
@@ -39,32 +39,33 @@
 
 class RAS_BucketManager
 {
-	//GEN_Map<class RAS_IPolyMaterial,class RAS_MaterialBucket*> m_MaterialBuckets;
-	
 	typedef std::vector<class RAS_MaterialBucket*> BucketList;
-	BucketList m_MaterialBuckets;
+	BucketList m_SolidBuckets;
 	BucketList m_AlphaBuckets;
 	
-	struct alphamesh;
+	struct sortedmeshslot;
 	struct backtofront;
+	struct fronttoback;
 
 public:
 	RAS_BucketManager();
 	virtual ~RAS_BucketManager();
 
-	void RenderAlphaBuckets(const MT_Transform& cameratrans, 
-		RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools);
 	void Renderbuckets(const MT_Transform & cameratrans,
-							RAS_IRasterizer* rasty,
-							class RAS_IRenderTools* rendertools);
+		RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools);
 
 	RAS_MaterialBucket* FindBucket(RAS_IPolyMaterial * material, bool &bucketCreated);
+	void OptimizeBuckets(MT_Scalar distance);
 	
-	void ReleaseDisplayLists();
+	void ReleaseDisplayLists(RAS_IPolyMaterial * material = NULL);
 
 private:
-	void RAS_BucketManagerClearAll();
+	void OrderBuckets(const MT_Transform& cameratrans, BucketList& buckets, vector<sortedmeshslot>& slots, bool alpha);
 
+	void RenderSolidBuckets(const MT_Transform& cameratrans, 
+		RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools);
+	void RenderAlphaBuckets(const MT_Transform& cameratrans, 
+		RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools);
 };
 
 #endif //__RAS_BUCKETMANAGER
diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp
index 4ee06d96603..fb3607f89f4 100644
--- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp
+++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp
@@ -42,11 +42,8 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname,
 									 int transp,
 									 bool alpha,
 									 bool zsort,
-									 int lightlayer,
-									 bool bIsTriangle,
-									 void* clientobject=NULL) :
-
-		m_texturename(texname),
+									 int lightlayer)
+		: m_texturename(texname),
 		m_materialname(matname),
 		m_tile(tile),
 		m_tilexrep(tilexrep),
@@ -56,7 +53,6 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname,
 		m_alpha(alpha),
 		m_zsort(zsort),
 		m_lightlayer(lightlayer),
-		m_bIsTriangle(bIsTriangle),
 		m_polymatid(m_newpolymatid++),
 		m_flag(0),
 		m_multimode(0)
@@ -72,15 +68,16 @@ bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const
 {
 	if(m_flag &RAS_BLENDERMAT)
 	{
-		return (
+		bool test = (
 			this->m_multimode			==		lhs.m_multimode &&
 			this->m_flag				==		lhs.m_flag		&&
 			this->m_drawingmode			==		lhs.m_drawingmode &&
 			this->m_transp				==		lhs.m_transp &&
-			this->m_lightlayer			==		lhs.m_lightlayer &&
 			this->m_texturename.hash()	==		lhs.m_texturename.hash() &&
 			this->m_materialname.hash() ==		lhs.m_materialname.hash()
 		);
+
+		return test;
 	}
 	else
 	{
@@ -92,8 +89,6 @@ bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const
 				this->m_alpha		==		lhs.m_alpha &&
 				this->m_zsort		==		lhs.m_zsort &&
 				this->m_drawingmode	==		lhs.m_drawingmode &&
-				this->m_bIsTriangle	==		lhs.m_bIsTriangle &&
-				this->m_lightlayer	==		lhs.m_lightlayer &&
 				this->m_texturename.hash()	==		lhs.m_texturename.hash() &&
 				this->m_materialname.hash() ==		lhs.m_materialname.hash()
 		);
@@ -123,11 +118,6 @@ bool RAS_IPolyMaterial::IsZSort() const
 	return m_zsort;
 }
 
-bool RAS_IPolyMaterial::UsesTriangles() const
-{
-	return m_bIsTriangle;
-}
-
 unsigned int RAS_IPolyMaterial::hash() const
 {
 	return m_texturename.hash();
@@ -172,5 +162,10 @@ bool RAS_IPolyMaterial::UsesLighting(RAS_IRasterizer *rasty) const
 	return dolights;
 }
 
+bool RAS_IPolyMaterial::UsesObjectColor() const
+{
+	return !(m_flag & RAS_BLENDERGLSL);
+}
+
 unsigned int RAS_IPolyMaterial::m_newpolymatid = 0;
 
diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h
index 8fc53e6b038..218dd91cb30 100644
--- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h
+++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h
@@ -71,7 +71,6 @@ protected:
 	bool					m_alpha;
 	bool					m_zsort;
 	int						m_lightlayer;
-	bool					m_bIsTriangle;
 	
 	unsigned int			m_polymatid;
 	static unsigned int		m_newpolymatid;
@@ -106,9 +105,7 @@ public:
 					  int transp,
 					  bool alpha,
 					  bool zsort,
-					  int lightlayer,
-					  bool bIsTriangle,
-					  void* clientobject);
+					  int lightlayer);
 	virtual ~RAS_IPolyMaterial() {};
  
 	/**
@@ -129,14 +126,13 @@ public:
 	{ 
 		return false; 
 	}
-	virtual void ActivateMeshSlot(const class KX_MeshSlot & ms, RAS_IRasterizer* rasty) const {}
+	virtual void ActivateMeshSlot(const class RAS_MeshSlot & ms, RAS_IRasterizer* rasty) const {}
 
 	virtual bool				Equals(const RAS_IPolyMaterial& lhs) const;
 	bool				Less(const RAS_IPolyMaterial& rhs) const;
 	int					GetLightLayer() const;
 	bool				IsAlpha() const;
 	bool				IsZSort() const;
-	bool				UsesTriangles() const;
 	unsigned int		hash() const;
 	int					GetDrawingMode() const;
 	const STR_String&	GetMaterialName() const;
@@ -145,6 +141,7 @@ public:
 	const unsigned int	GetFlag() const;
 
 	virtual bool		UsesLighting(RAS_IRasterizer *rasty) const;
+	virtual bool		UsesObjectColor() const;
 	
 	/*
 	 * PreCalculate texture gen
diff --git a/source/gameengine/Rasterizer/RAS_IRasterizer.h b/source/gameengine/Rasterizer/RAS_IRasterizer.h
index 9e03212283e..1d18d02a583 100644
--- a/source/gameengine/Rasterizer/RAS_IRasterizer.h
+++ b/source/gameengine/Rasterizer/RAS_IRasterizer.h
@@ -217,39 +217,18 @@ public:
 	
 	// Drawing Functions
 	/**
-	 * IndexPrimitives: Renders primitives.
-	 * @param vertexarrays is an array of vertex arrays
-	 * @param indexarrays is an array of index arrays
-	 * @param mode determines the type of primitive stored in the vertex/index arrays
-	 * @param useObjectColor will render the object using @param rgbacolor instead of 
-	 *  vertex colors.
-	 */
-	virtual void IndexPrimitives( const vecVertexArray& vertexarrays,
-							const vecIndexArrays & indexarrays,
-							DrawMode mode,
-							bool useObjectColor,
-							const MT_Vector4& rgbacolor,
-							class KX_ListSlot** slot)=0;
-
-	virtual void IndexPrimitivesMulti( 
-						const vecVertexArray& vertexarrays,
-						const vecIndexArrays & indexarrays,
-						DrawMode mode,
-						bool useObjectColor,
-						const MT_Vector4& rgbacolor,
-						class KX_ListSlot** slot)=0;
+	 * IndexPrimitives: Renders primitives from mesh slot.
+	 */
+	virtual void IndexPrimitives(class RAS_MeshSlot& ms)=0;
+	virtual void IndexPrimitivesMulti(class RAS_MeshSlot& ms)=0;
 
 	/**
 	 * IndexPrimitives_3DText will render text into the polygons.
 	 * The text to be rendered is from @param rendertools client object's text property.
 	 */
-	virtual void	IndexPrimitives_3DText( const vecVertexArray& vertexarrays,
-							const vecIndexArrays & indexarrays,
-							DrawMode mode,
+	virtual void	IndexPrimitives_3DText(class RAS_MeshSlot& ms,
 							class RAS_IPolyMaterial* polymat,
-							class RAS_IRenderTools* rendertools,
-							bool useObjectColor,
-							const MT_Vector4& rgbacolor)=0;
+							class RAS_IRenderTools* rendertools)=0;
 
 	virtual void	SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0;
 	/* This one should become our final version, methinks. */
@@ -271,9 +250,6 @@ public:
 	virtual const	MT_Point3& GetCameraPosition()=0;
 	/**
 	 */
-	virtual void	LoadViewMatrix()=0;
-	/**
-	 */
 	virtual void	SetFog(float start,
 						   float dist,
 						   float r,
@@ -309,9 +285,6 @@ public:
 	 */
 	virtual int	GetDrawingMode()=0;
 	/**
-	 */
-	virtual void	EnableTextures(bool enable)=0;
-	/**
 	 * Sets face culling
 	 */	
 	virtual void	SetCullFace(bool enable)=0;
@@ -385,7 +358,9 @@ public:
 	virtual void	SetAttribNum(int num) = 0;
 	virtual void	SetTexCoord(TexCoGen coords, int unit) = 0;
 	virtual void	SetAttrib(TexCoGen coords, int unit) = 0;
-	virtual void	GetViewMatrix(MT_Matrix4x4 &mat) const = 0;
+
+	virtual const MT_Matrix4x4&	GetViewMatrix() const = 0;
+	virtual const MT_Matrix4x4&	GetViewInvMatrix() const = 0;
 
 	virtual bool	QueryLists(){return false;}
 	virtual bool	QueryArrays(){return false;}
@@ -398,6 +373,7 @@ public:
 	virtual void	SetMotionBlurState(int newstate)=0;
 
 	virtual void	SetBlendingMode(int blendmode)=0;
+	virtual void	SetFrontFace(bool ccw)=0;
 };
 
 #endif //__RAS_IRASTERIZER
diff --git a/source/gameengine/Rasterizer/RAS_IRenderTools.cpp b/source/gameengine/Rasterizer/RAS_IRenderTools.cpp
index 2be9bb75ebf..555a3520bb4 100644
--- a/source/gameengine/Rasterizer/RAS_IRenderTools.cpp
+++ b/source/gameengine/Rasterizer/RAS_IRenderTools.cpp
@@ -28,42 +28,22 @@
 
 #include "RAS_IRenderTools.h"
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-void RAS_IRenderTools::SetViewMat(const MT_Transform& trans)
-{
-	trans.getValue(m_viewmat);
-}
-	
-
-
-void RAS_IRenderTools::SetClientObject(void* obj)
+void RAS_IRenderTools::SetClientObject(RAS_IRasterizer* rasty, void *obj)
 {
 	if (m_clientobject != obj)
-	{
 		m_clientobject = obj;
-		m_modified = true;
-	}
 }
 
-
-
 void RAS_IRenderTools::SetAuxilaryClientInfo(void* inf)
 {
 	m_auxilaryClientInfo = inf;
 }
 
-
-
 void RAS_IRenderTools::AddLight(struct RAS_LightObject* lightobject)
 {
 	m_lights.push_back(lightobject);
 }
 
-
-
 void RAS_IRenderTools::RemoveLight(struct RAS_LightObject* lightobject)
 {
 	std::vector<struct	RAS_LightObject*>::iterator lit = 
@@ -71,5 +51,5 @@ void RAS_IRenderTools::RemoveLight(struct RAS_LightObject* lightobject)
 
 	if (!(lit==m_lights.end()))
 		m_lights.erase(lit);
-
 }
+
diff --git a/source/gameengine/Rasterizer/RAS_IRenderTools.h b/source/gameengine/Rasterizer/RAS_IRenderTools.h
index 54a663ba111..57f331e64cb 100644
--- a/source/gameengine/Rasterizer/RAS_IRenderTools.h
+++ b/source/gameengine/Rasterizer/RAS_IRenderTools.h
@@ -44,12 +44,9 @@ class RAS_IRenderTools
 {
 
 protected:
-	float	m_viewmat[16];
 	void*	m_clientobject;
 	void*	m_auxilaryClientInfo;
 
-	bool	m_modified;
-	
 	std::vector<struct	RAS_LightObject*> m_lights;
 	
 	RAS_2DFilterManager m_filtermanager;
@@ -68,8 +65,7 @@ public:
 
 	RAS_IRenderTools(
 	) :
-		m_clientobject(NULL),
-		m_modified(true)
+		m_clientobject(NULL)
 	{
 	};
 
@@ -131,24 +127,21 @@ public:
 		float v1[3],
 		float v2[3],
 		float v3[3],
-		float v4[3]
+		float v4[3],
+		int glattrib
 	)=0;
 
 	virtual 
-		void	
-	SetViewMat(
-		const MT_Transform& trans
-	);
-
-	virtual 
-		int		
+		void		
 	ProcessLighting(
-		int layer
+		int layer,
+		const MT_Transform& trans
 	)=0;
 
 	virtual
 		void	
 	SetClientObject(
+		RAS_IRasterizer* rasty,
 		void* obj
 	);
 
@@ -190,24 +183,6 @@ public:
 	virtual
 		void
 		Render2DFilters(RAS_ICanvas* canvas)=0;
-
-	virtual 
-		class RAS_IPolyMaterial*	
-	CreateBlenderPolyMaterial(
-		const STR_String &texname,
-		bool ba,
-		const STR_String& matname,
-		int tile,
-		int tilexrep,
-		int tileyrep,
-		int mode,
-		bool transparant,
-		bool zsort,
-		int lightlayer,
-		bool bIsTriangle,
-		void* clientobject,
-		void* tface
-	)=0;
 };
 
 #endif //__RAS_IRENDERTOOLS
diff --git a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp
index 0015b6a251f..e003cdc9368 100644
--- a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp
+++ b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp
@@ -28,10 +28,6 @@
 
 #include "RAS_MaterialBucket.h"
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #ifdef WIN32
 #pragma warning (disable:4786)
 #include <windows.h>
@@ -44,79 +40,408 @@
 #include "RAS_MeshObject.h"
 #include "RAS_Deformer.h"	// __NLA
 
+/* mesh slot */
+
+RAS_MeshSlot::RAS_MeshSlot()
+{
+	m_clientObj = NULL;
+	m_pDeformer = NULL;
+	m_OpenGLMatrix = NULL;
+	m_mesh = NULL;
+	m_bucket = NULL;
+	m_bVisible = false;
+	m_bCulled = true;
+	m_bObjectColor = false;
+	m_RGBAcolor = MT_Vector4(0.0, 0.0, 0.0, 0.0);
+	m_DisplayList = NULL;
+	m_bDisplayList = true;
+	m_joinSlot = NULL;
+}
+
+RAS_MeshSlot::~RAS_MeshSlot()
+{
+	vector<RAS_DisplayArray*>::iterator it;
+
+	Split(true);
+
+	while(m_joinedSlots.size())
+		m_joinedSlots.front()->Split(true);
 
+	for(it=m_displayArrays.begin(); it!=m_displayArrays.end(); it++) {
+		(*it)->m_users--;
+		if((*it)->m_users == 0)
+			delete *it;
+	}
+
+	if (m_DisplayList) {
+		m_DisplayList->Release();
+		m_DisplayList = NULL;
+	}
+}
 
-KX_VertexIndex::KX_VertexIndex(int size)
+RAS_MeshSlot::RAS_MeshSlot(const RAS_MeshSlot& slot)
 {
-	m_size = size;
+	vector<RAS_DisplayArray*>::iterator it;
+
+	m_clientObj = NULL;
+	m_pDeformer = NULL;
+	m_OpenGLMatrix = NULL;
+	m_mesh = slot.m_mesh;
+	m_bucket = slot.m_bucket;
+	m_bVisible = slot.m_bVisible;
+	m_bCulled = slot.m_bCulled;
+	m_bObjectColor = slot.m_bObjectColor;
+	m_RGBAcolor = slot.m_RGBAcolor;
+	m_DisplayList = NULL;
+	m_bDisplayList = slot.m_bDisplayList;
+	m_joinSlot = NULL;
+	m_currentArray = slot.m_currentArray;
+	m_displayArrays = slot.m_displayArrays;
+	m_joinedSlots = slot.m_joinedSlots;
+
+	m_startarray = slot.m_startarray;
+	m_startvertex = slot.m_startvertex;
+	m_startindex = slot.m_startindex;
+	m_endarray = slot.m_endarray;
+	m_endvertex = slot.m_endvertex;
+	m_endindex = slot.m_endindex;
+
+	for(it=m_displayArrays.begin(); it!=m_displayArrays.end(); it++) {
+		*it = new RAS_DisplayArray(**it);
+		(*it)->m_users = 1;
+	}
 }
 
+void RAS_MeshSlot::init(RAS_MaterialBucket *bucket, int numverts)
+{
+	m_bucket = bucket;
+
+	SetDisplayArray(numverts);
 
+	m_startarray = 0;
+	m_startvertex = 0;
+	m_startindex = 0;
+	m_endarray = 0;
+	m_endvertex = 0;
+	m_endindex = 0;
+}
 
-void KX_VertexIndex::SetIndex(short loc,unsigned int index)
+void RAS_MeshSlot::begin(RAS_MeshSlot::iterator& it)
 {
-	m_indexarray[loc]=index;
+	int startvertex, endvertex;
+	int startindex, endindex;
+
+	it.array = m_displayArrays[m_startarray];
+
+	startvertex = m_startvertex;
+	endvertex = (m_startarray == m_endarray)? m_endvertex: it.array->m_vertex.size();
+	startindex = m_startindex;
+	endindex = (m_startarray == m_endarray)? m_endindex: it.array->m_index.size();
+
+	it.vertex = &it.array->m_vertex[0];
+	it.index = &it.array->m_index[startindex];
+	it.startvertex = startvertex;
+	it.endvertex = endvertex;
+	it.totindex = endindex-startindex;
+	it.arraynum = m_startarray;
 }
 
-bool KX_MeshSlot::Less(const KX_MeshSlot& lhs) const
+void RAS_MeshSlot::next(RAS_MeshSlot::iterator& it)
 {
-	bool result = ((m_mesh < lhs.m_mesh ) ||
-		((m_mesh == lhs.m_mesh)&&(m_OpenGLMatrix < lhs.m_OpenGLMatrix)));
-	
-	return result;
+	int startvertex, endvertex;
+	int startindex, endindex;
+
+	if(it.arraynum == (size_t)m_endarray) {
+		it.array = NULL;
+		it.vertex = NULL;
+		it.index = NULL;
+		it.startvertex = 0;
+		it.endvertex = 0;
+		it.totindex = 0;
+	}
+	else {
+		it.arraynum++;
+		it.array = m_displayArrays[it.arraynum];
+
+		startindex = 0;
+		endindex = (it.arraynum == (size_t)m_endarray)? m_endindex: it.array->m_index.size();
+		startvertex = 0;
+		endvertex = (it.arraynum == (size_t)m_endarray)? m_endvertex: it.array->m_vertex.size();
+
+		it.vertex = &it.array->m_vertex[0];
+		it.index = &it.array->m_index[startindex];
+		it.startvertex = startvertex;
+		it.endvertex = endvertex;
+		it.totindex = endindex-startindex;
+	}
 }
 
-KX_MeshSlot::~KX_MeshSlot()
+bool RAS_MeshSlot::end(RAS_MeshSlot::iterator& it)
 {
-	if (m_DisplayList)
-		m_DisplayList->Release();
+	return (it.array == NULL);
 }
 
+RAS_DisplayArray *RAS_MeshSlot::CurrentDisplayArray()
+{
+	return m_currentArray;
+}
 
-RAS_MaterialBucket::RAS_MaterialBucket(RAS_IPolyMaterial* mat)
-	:m_bModified(true)
+void RAS_MeshSlot::SetDisplayArray(int numverts)
 {
-	m_material = mat;
+	vector<RAS_DisplayArray*>::iterator it;
+	RAS_DisplayArray *darray = NULL;
+	
+	for(it=m_displayArrays.begin(); it!=m_displayArrays.end(); it++) {
+		darray = *it;
+
+		if(darray->m_type == numverts) {
+			if(darray->m_index.size()+numverts >= RAS_DisplayArray::BUCKET_MAX_INDEX)
+				darray = NULL;
+			else if(darray->m_vertex.size()+numverts >= RAS_DisplayArray::BUCKET_MAX_VERTEX)
+				darray = NULL;
+			else
+				break;
+		}
+		else
+			darray = NULL;
+	}
+
+	if(!darray) {
+		darray = new RAS_DisplayArray();
+		darray->m_users = 1;
+
+		if(numverts == 2) darray->m_type = RAS_DisplayArray::LINE;
+		else if(numverts == 3) darray->m_type = RAS_DisplayArray::TRIANGLE;
+		else darray->m_type = RAS_DisplayArray::QUAD;
+
+		m_displayArrays.push_back(darray);
+
+		if(numverts == 2)
+			darray->m_type = RAS_DisplayArray::LINE;
+		else if(numverts == 3)
+			darray->m_type = RAS_DisplayArray::TRIANGLE;
+		else if(numverts == 4)
+			darray->m_type = RAS_DisplayArray::QUAD;
+		
+		m_endarray = m_displayArrays.size()-1;
+		m_endvertex = 0;
+		m_endindex = 0;
+	}
+
+	m_currentArray = darray;
 }
 
+void RAS_MeshSlot::AddPolygon(int numverts)
+{
+	SetDisplayArray(numverts);
+}
 
+int RAS_MeshSlot::AddVertex(const RAS_TexVert& tv)
+{
+	RAS_DisplayArray *darray;
+	int offset;
+	
+	darray = m_currentArray;
+	darray->m_vertex.push_back(tv);
+	offset = darray->m_vertex.size()-1;
 
-RAS_IPolyMaterial* RAS_MaterialBucket::GetPolyMaterial() const
-{ 
-	return m_material;
+	if(darray == m_displayArrays[m_endarray])
+		m_endvertex++;
+
+	return offset;
 }
 
+void RAS_MeshSlot::AddPolygonVertex(int offset)
+{
+	RAS_DisplayArray *darray;
+
+	darray = m_currentArray;
+	darray->m_index.push_back(offset);
+
+	if(darray == m_displayArrays[m_endarray])
+		m_endindex++;
+}
 
+bool RAS_MeshSlot::Equals(RAS_MeshSlot *target)
+{
+	if(!m_OpenGLMatrix || !target->m_OpenGLMatrix)
+		return false;
+	if(m_pDeformer || target->m_pDeformer)
+		return false;
+	if(m_bVisible != target->m_bVisible)
+		return false;
+	if(m_bObjectColor != target->m_bObjectColor)
+		return false;
+	if(m_bObjectColor && !(m_RGBAcolor == target->m_RGBAcolor))
+		return false;
 	
-void RAS_MaterialBucket::SetMeshSlot(KX_MeshSlot& ms)
+	return true;
+}
+
+bool RAS_MeshSlot::Join(RAS_MeshSlot *target, MT_Scalar distance)
 {
-	m_meshSlots.insert(ms);
+	vector<RAS_DisplayArray*>::iterator it;
+	iterator mit;
+	size_t i;
+
+	// verify if we can join
+	if(m_joinSlot || m_joinedSlots.size() || target->m_joinSlot)
+		return false;
+
+	if(!Equals(target))
+		return false;
+	
+	MT_Vector3 co(&m_OpenGLMatrix[12]);
+	MT_Vector3 targetco(&target->m_OpenGLMatrix[12]);
+
+	if((co - targetco).length() > distance)
+		return false;
+
+	MT_Matrix4x4 mat(m_OpenGLMatrix);
+	MT_Matrix4x4 targetmat(target->m_OpenGLMatrix);
+	targetmat.invert();
+
+	MT_Matrix4x4 transform = targetmat*mat;
+	
+	// m_mesh, clientobj
+	m_joinSlot = target;
+	m_joinInvTransform = transform;
+	m_joinInvTransform.invert();
+	target->m_joinedSlots.push_back(this);
+
+	MT_Matrix4x4 ntransform = m_joinInvTransform.transposed();
+	ntransform[0][3]= ntransform[1][3]= ntransform[2][3]= 0.0f;
+
+	for(begin(mit); !end(mit); next(mit))
+		for(i=mit.startvertex; i<mit.endvertex; i++)
+			mit.vertex[i].Transform(transform, ntransform);
+
+	for(it=m_displayArrays.begin(); it!=m_displayArrays.end(); it++) {
+		target->m_displayArrays.push_back(*it);
+		target->m_endarray++;
+		target->m_endvertex = target->m_displayArrays.back()->m_vertex.size();
+		target->m_endindex = target->m_displayArrays.back()->m_index.size();
+	}
+
+	if (m_DisplayList) {
+		m_DisplayList->Release();
+		m_DisplayList = NULL;
+	}
+	if (target->m_DisplayList) {
+		target->m_DisplayList->Release();
+		target->m_DisplayList = NULL;
+	}
+	
+	return true;
+#if 0
+	return false;
+#endif
 }
 
+bool RAS_MeshSlot::Split(bool force)
+{
+	list<RAS_MeshSlot*>::iterator jit;
+	RAS_MeshSlot *target = m_joinSlot;
+	vector<RAS_DisplayArray*>::iterator it, jt;
+	iterator mit;
+	size_t i, found0 = 0, found1 = 0;
+
+	if(target && (force || !Equals(target))) {
+		m_joinSlot = NULL;
+
+		for(jit=target->m_joinedSlots.begin(); jit!=target->m_joinedSlots.end(); jit++) {
+			if(*jit == this) {
+				target->m_joinedSlots.erase(jit);
+				found0 = 1;
+				break;
+			}
+		}
+
+		if(!found0)
+			abort();
+
+		for(it=m_displayArrays.begin(); it!=m_displayArrays.end(); it++) {
+			found1 = 0;
+			for(jt=target->m_displayArrays.begin(); jt!=target->m_displayArrays.end(); jt++) {
+				if(*jt == *it) {
+					target->m_displayArrays.erase(jt);
+					target->m_endarray--;
+					found1 = 1;
+					break;
+				}
+			}
+
+			if(!found1)
+				abort();
+		}
+
+		if(target->m_displayArrays.size()) {
+			target->m_endvertex = target->m_displayArrays.back()->m_vertex.size();
+			target->m_endindex = target->m_displayArrays.back()->m_index.size();
+		}
+		else {
+			target->m_endvertex = 0;
+			target->m_endindex = 0;
+		}
+
+		MT_Matrix4x4 ntransform = m_joinInvTransform.inverse().transposed();
+		ntransform[0][3]= ntransform[1][3]= ntransform[2][3]= 0.0f;
 
+		for(begin(mit); !end(mit); next(mit))
+			for(i=mit.startvertex; i<mit.endvertex; i++)
+				mit.vertex[i].Transform(m_joinInvTransform, ntransform);
+
+		if (target->m_DisplayList) {
+			target->m_DisplayList->Release();
+			target->m_DisplayList = NULL;
+		}
+
+		return true;
+	}
 
-void RAS_MaterialBucket::RemoveMeshSlot(KX_MeshSlot& ms)
+	return false;
+}
+
+bool RAS_MeshSlot::IsCulled()
 {
-	T_MeshSlotList::iterator it = m_meshSlots.find(ms);
+	list<RAS_MeshSlot*>::iterator it;
 
-	if (!(it == m_meshSlots.end()))
-		m_meshSlots.erase(it);
-			
+	if(m_joinSlot)
+		return true;
+	if(!m_bCulled)
+		return false;
+	
+	for(it=m_joinedSlots.begin(); it!=m_joinedSlots.end(); it++)
+		if(!(*it)->m_bCulled)
+			return false;
+	
+	return true;
 }
 
+/* material bucket sorting */
+
+struct RAS_MaterialBucket::less
+{
+	bool operator()(const RAS_MaterialBucket* x, const RAS_MaterialBucket* y) const 
+	{ 
+		return *x->GetPolyMaterial() < *y->GetPolyMaterial(); 
+	}
+};
 
+/* material bucket */
 
-void RAS_MaterialBucket::MarkVisibleMeshSlot(KX_MeshSlot& ms,
-											 bool visible,
-											 bool color,
-											 const MT_Vector4& rgbavec)
+RAS_MaterialBucket::RAS_MaterialBucket(RAS_IPolyMaterial* mat)
+{
+	m_material = mat;
+}
+
+RAS_MaterialBucket::~RAS_MaterialBucket()
 {
-	T_MeshSlotList::iterator it = m_meshSlots.find(ms);
-			
-	assert (!(it == m_meshSlots.end())); 
-	(*it).m_bVisible = visible;
-	(*it).m_bObjectColor = color;
-	(*it).m_RGBAcolor= rgbavec;
+}
+
+RAS_IPolyMaterial* RAS_MaterialBucket::GetPolyMaterial() const
+{ 
+	return m_material;
 }
 
 bool RAS_MaterialBucket::IsAlpha() const
@@ -129,162 +454,129 @@ bool RAS_MaterialBucket::IsZSort() const
 	return (m_material->IsZSort());
 }
 
-
-
-void RAS_MaterialBucket::StartFrame()
+RAS_MeshSlot* RAS_MaterialBucket::AddMesh(int numverts)
 {
-}
+	RAS_MeshSlot *ms;
 
+	m_meshSlots.push_back(RAS_MeshSlot());
+	
+	ms = &m_meshSlots.back();
+	ms->init(this, numverts);
 
+	return ms;
+}
 
-void RAS_MaterialBucket::EndFrame()
+RAS_MeshSlot* RAS_MaterialBucket::CopyMesh(RAS_MeshSlot *ms)
 {
+	m_meshSlots.push_back(RAS_MeshSlot(*ms));
+	
+	return &m_meshSlots.back();
 }
 
-unsigned int RAS_MaterialBucket::NumMeshSlots()
+void RAS_MaterialBucket::RemoveMesh(RAS_MeshSlot* ms)
 {
-	return m_meshSlots.size();
+	list<RAS_MeshSlot>::iterator it;
+
+	for(it=m_meshSlots.begin(); it!=m_meshSlots.end(); it++) {
+		if(&*it == ms) {
+			m_meshSlots.erase(it);
+			return;
+		}
+	}
 }
 
-RAS_MaterialBucket::T_MeshSlotList::iterator RAS_MaterialBucket::msBegin()
+list<RAS_MeshSlot>::iterator RAS_MaterialBucket::msBegin()
 {
 	return m_meshSlots.begin();
 }
 
-RAS_MaterialBucket::T_MeshSlotList::iterator RAS_MaterialBucket::msEnd()
+list<RAS_MeshSlot>::iterator RAS_MaterialBucket::msEnd()
 {
 	return m_meshSlots.end();
 }
 
 bool RAS_MaterialBucket::ActivateMaterial(const MT_Transform& cameratrans, RAS_IRasterizer* rasty,
-	RAS_IRenderTools *rendertools, RAS_IRasterizer::DrawMode &drawmode)
+	RAS_IRenderTools *rendertools)
 {
-	rendertools->SetViewMat(cameratrans);
-
 	if (!rasty->SetMaterial(*m_material))
 		return false;
 	
 	if (m_material->UsesLighting(rasty))
-		rendertools->ProcessLighting(RAS_IRenderTools::RAS_LIGHT_OBJECT_LAYER/*m_material->GetLightLayer()*/);
-	else
-		rendertools->ProcessLighting(-1);
-
-	if(rasty->GetDrawingMode() < RAS_IRasterizer::KX_SOLID)
-		drawmode = RAS_IRasterizer::KX_MODE_LINES;
-	else if(m_material->UsesTriangles())
-		drawmode = RAS_IRasterizer::KX_MODE_TRIANGLES;
+		rendertools->ProcessLighting(RAS_IRenderTools::RAS_LIGHT_OBJECT_LAYER, cameratrans);
 	else
-		drawmode = RAS_IRasterizer::KX_MODE_QUADS;
+		rendertools->ProcessLighting(-1, cameratrans);
 	
 	return true;
 }
 
 void RAS_MaterialBucket::RenderMeshSlot(const MT_Transform& cameratrans, RAS_IRasterizer* rasty,
-	RAS_IRenderTools* rendertools, const KX_MeshSlot &ms, RAS_IRasterizer::DrawMode drawmode)
+	RAS_IRenderTools* rendertools, RAS_MeshSlot &ms)
 {
-	if (!ms.m_bVisible)
-		return;
-	
 	m_material->ActivateMeshSlot(ms, rasty);
 
-	/* __NLA Do the deformation */
 	if (ms.m_pDeformer)
 	{
 		ms.m_pDeformer->Apply(m_material);
 	//	KX_ReInstanceShapeFromMesh(ms.m_mesh); // Recompute the physics mesh. (Can't call KX_* from RAS_)
 	}
-	/* End __NLA */
 	
-	if (rasty->GetDrawingMode() >= RAS_IRasterizer::KX_SOLID)
-		ms.m_mesh->SortPolygons(cameratrans*MT_Transform(ms.m_OpenGLMatrix));
+	if(IsZSort() && rasty->GetDrawingMode() >= RAS_IRasterizer::KX_SOLID)
+		ms.m_mesh->SortPolygons(ms, cameratrans*MT_Transform(ms.m_OpenGLMatrix));
 
 	rendertools->PushMatrix();
 	rendertools->applyTransform(rasty,ms.m_OpenGLMatrix,m_material->GetDrawingMode());
 
 	if(rasty->QueryLists())
-	{
 		if(ms.m_DisplayList)
 			ms.m_DisplayList->SetModified(ms.m_mesh->MeshModified());
-	}
 
 	// verify if we can use display list, not for deformed object, and
 	// also don't create a new display list when drawing shadow buffers,
-	// then it won't have texture coordinates for actual drawing
-	KX_ListSlot **displaylist;
+	// then it won't have texture coordinates for actual drawing. also
+	// for zsort we can't make a display list, since the polygon order
+	// changes all the time.
 	if(ms.m_pDeformer)
-		displaylist = 0;
+		ms.m_bDisplayList = false;
 	else if(!ms.m_DisplayList && rasty->GetDrawingMode() == RAS_IRasterizer::KX_SHADOW)
-		displaylist = 0;
+		ms.m_bDisplayList = false;
+	else if (IsZSort())
+		ms.m_bDisplayList = false;
+	else if(m_material->UsesObjectColor() && ms.m_bObjectColor)
+		ms.m_bDisplayList = false;
 	else
-		displaylist = &ms.m_DisplayList;
+		ms.m_bDisplayList = true;
 
-	// Use the text-specific IndexPrimitives for text faces
+	// for text drawing using faces
 	if (m_material->GetDrawingMode() & RAS_IRasterizer::RAS_RENDER_3DPOLYGON_TEXT)
-	{
-		rasty->IndexPrimitives_3DText(
-				ms.m_mesh->GetVertexCache(m_material), 
-				ms.m_mesh->GetIndexCache(m_material), 
-				drawmode,
-				m_material,
-				rendertools, // needed for textprinting on polys
-				ms.m_bObjectColor,
-				ms.m_RGBAcolor);
-	}
-
-	// for using glMultiTexCoord
+		rasty->IndexPrimitives_3DText(ms, m_material, rendertools);
+	// for multitexturing
 	else if((m_material->GetFlag() & RAS_MULTITEX))
-	{
-		rasty->IndexPrimitivesMulti(
-				ms.m_mesh->GetVertexCache(m_material), 
-				ms.m_mesh->GetIndexCache(m_material), 
-				drawmode,
-				ms.m_bObjectColor,
-				ms.m_RGBAcolor,
-				displaylist);
-	}
-
-	// Use the normal IndexPrimitives
+		rasty->IndexPrimitivesMulti(ms);
+	// use normal IndexPrimitives
 	else
-	{
-		rasty->IndexPrimitives(
-				ms.m_mesh->GetVertexCache(m_material), 
-				ms.m_mesh->GetIndexCache(m_material), 
-				drawmode,
-				ms.m_bObjectColor,
-				ms.m_RGBAcolor,
-				displaylist);
-	}
+		rasty->IndexPrimitives(ms);
 
-	if(rasty->QueryLists()) {
+	if(rasty->QueryLists())
 		if(ms.m_DisplayList)
 			ms.m_mesh->SetMeshModified(false);
-	}
 
 	rendertools->PopMatrix();
 }
 
-void RAS_MaterialBucket::Render(const MT_Transform& cameratrans,
-								RAS_IRasterizer* rasty,
-								RAS_IRenderTools* rendertools)
+void RAS_MaterialBucket::Optimize(MT_Scalar distance)
 {
-	if (m_meshSlots.begin()== m_meshSlots.end())
-		return;
-		
-	//rendertools->SetViewMat(cameratrans);
-
-	//rasty->SetMaterial(*m_material);
+	/* TODO: still have to check before this works correct:
+	 * - lightlayer, frontface, text, billboard
+	 * - make it work with physics */
 	
-	RAS_IRasterizer::DrawMode drawmode;
-	for (T_MeshSlotList::const_iterator it = m_meshSlots.begin();
-	! (it == m_meshSlots.end()); ++it)
-	{
-		rendertools->SetClientObject((*it).m_clientObj);
-		while (ActivateMaterial(cameratrans, rasty, rendertools, drawmode)) {
-			RenderMeshSlot(cameratrans, rasty, rendertools, *it, drawmode);
-		}
-	}
-	// to reset the eventual GL_CW mode
-	rendertools->SetClientObject(NULL);
+#if 0
+	list<RAS_MeshSlot>::iterator it;
+	list<RAS_MeshSlot>::iterator jt;
+
+	// greed joining on all following buckets
+	for(it=m_meshSlots.begin(); it!=m_meshSlots.end(); it++)
+		for(jt=it, jt++; jt!=m_meshSlots.end(); jt++)
+			jt->Join(&*it, distance);
+#endif
 }
 
-
diff --git a/source/gameengine/Rasterizer/RAS_MaterialBucket.h b/source/gameengine/Rasterizer/RAS_MaterialBucket.h
index 4eef889c533..475f01d549a 100644
--- a/source/gameengine/Rasterizer/RAS_MaterialBucket.h
+++ b/source/gameengine/Rasterizer/RAS_MaterialBucket.h
@@ -36,30 +36,15 @@
 #include "MT_Transform.h"
 #include "RAS_IPolygonMaterial.h"
 #include "RAS_IRasterizer.h"
-#include "RAS_Deformer.h"	// __NLA
+#include "RAS_Deformer.h"
+
 #include <vector>
-#include <map>
 #include <set>
+#include <list>
 using namespace std;
 
-/**
- * KX_VertexIndex
- */
-struct KX_VertexIndex {
-public:
-	KX_VertexIndex(int size);
-	void	SetIndex(short loc,unsigned int index);
-	
-	// The vertex array
-	short	m_vtxarray;
-	// An index into the vertex array for up to 4 verticies
-	unsigned short	m_indexarray[4];
-	short	m_size;
-};
+/* Display List Slot */
 
-/**
- * KX_ListSlot.
- */
 class KX_ListSlot
 {
 protected:
@@ -80,91 +65,149 @@ public:
 	virtual void SetModified(bool mod)=0;
 };
 
-/**
- * KX_MeshSlot.
- */
-class KX_MeshSlot
+class RAS_DisplayArray;
+class RAS_MeshSlot;
+class RAS_MeshMaterial;
+class RAS_MaterialBucket;
+
+/* An array with data used for OpenGL drawing */
+
+class RAS_DisplayArray
 {
 public:
-	void*						m_clientObj;
-	RAS_Deformer*				m_pDeformer;	//	__NLA
-	double*						m_OpenGLMatrix;
-	class RAS_MeshObject*		m_mesh;
-	mutable bool				m_bVisible; // for visibility
-	mutable bool				m_bObjectColor;
-	mutable MT_Vector4			m_RGBAcolor;
-	mutable KX_ListSlot*		m_DisplayList; // for lists
-	KX_MeshSlot() :
-		m_pDeformer(NULL), 
-		m_bVisible(true),
-		m_DisplayList(0)
-	{
-	}
-	~KX_MeshSlot();
-	bool					Less(const KX_MeshSlot& lhs) const;
+	vector<RAS_TexVert> m_vertex;
+	vector<unsigned short> m_index;
+	enum { LINE = 2, TRIANGLE = 3, QUAD = 4 } m_type;
+	//RAS_MeshSlot *m_origSlot;
+	int m_users;
+
+	enum { BUCKET_MAX_INDEX = 65535 };
+	enum { BUCKET_MAX_VERTEX = 65535 };
 };
 
+/* Entry of a RAS_MeshObject into RAS_MaterialBucket */
 
-inline bool operator <( const KX_MeshSlot& rhs,const KX_MeshSlot& lhs)
+class RAS_MeshSlot
 {
-	return ( rhs.Less(lhs));
-}
+private:
+	//  indices into display arrays
+	int							m_startarray;
+	int							m_endarray;
+	int							m_startindex;
+	int							m_endindex;
+	int							m_startvertex;
+	int							m_endvertex;
+	vector<RAS_DisplayArray*>	m_displayArrays;
+
+	// for construction only
+	RAS_DisplayArray*			m_currentArray;
+
+public:
+	// for rendering
+	RAS_MaterialBucket*		m_bucket;
+	RAS_MeshObject*			m_mesh;
+	void*					m_clientObj;
+	RAS_Deformer*			m_pDeformer;
+	double*					m_OpenGLMatrix;
+	// visibility
+	bool					m_bVisible;
+	bool					m_bCulled;
+	// object color
+	bool					m_bObjectColor;
+	MT_Vector4				m_RGBAcolor;
+	// display lists
+	KX_ListSlot*			m_DisplayList;
+	bool					m_bDisplayList;
+	// joined mesh slots
+	RAS_MeshSlot*			m_joinSlot;
+	MT_Matrix4x4			m_joinInvTransform;
+	list<RAS_MeshSlot*>		m_joinedSlots;
+
+	RAS_MeshSlot();
+	RAS_MeshSlot(const RAS_MeshSlot& slot);
+	virtual ~RAS_MeshSlot();
+	
+	void init(RAS_MaterialBucket *bucket, int numverts);
+
+	struct iterator {
+		RAS_DisplayArray *array;
+		RAS_TexVert *vertex;
+		unsigned short *index;
+		size_t startvertex;
+		size_t endvertex;
+		size_t totindex;
+		size_t arraynum;
+	};
+
+	void begin(iterator& it);
+	void next(iterator& it);
+	bool end(iterator& it);
+
+	/* used during construction */
+	void SetDisplayArray(int numverts);
+	RAS_DisplayArray *CurrentDisplayArray();
+
+	void AddPolygon(int numverts);
+	int AddVertex(const RAS_TexVert& tv);
+	void AddPolygonVertex(int offset);
+
+	/* optimization */
+	bool Split(bool force=false);
+	bool Join(RAS_MeshSlot *target, MT_Scalar distance);
+	bool Equals(RAS_MeshSlot *target);
+	bool IsCulled();
+};
+
+/* Used by RAS_MeshObject, to point to it's slots in a bucket */
+
+class RAS_MeshMaterial
+{
+public:
+	RAS_MeshSlot *m_baseslot;
+	class RAS_MaterialBucket *m_bucket;
+
+	GEN_Map<GEN_HashedPtr,RAS_MeshSlot*> m_slots;
+};
+
+/* Contains a list of display arrays with the same material,
+ * and a mesh slot for each mesh that uses display arrays in
+ * this bucket */
 
-/**
- * Contains a list of meshs with the same material properties.
- */
 class RAS_MaterialBucket
 {
 public:
-	typedef std::set<KX_MeshSlot> T_MeshSlotList;
-	
 	RAS_MaterialBucket(RAS_IPolyMaterial* mat);
-	virtual ~RAS_MaterialBucket() {}
-	
-	void	Render(const MT_Transform& cameratrans,
-					   class RAS_IRasterizer* rasty,
-					   class RAS_IRenderTools* rendertools);
+	virtual ~RAS_MaterialBucket();
 	
+	/* Bucket Sorting */
+	struct less;
+	typedef set<RAS_MaterialBucket*, less> Set;
+
+	/* Material Properties */
 	RAS_IPolyMaterial*		GetPolyMaterial() const;
-	bool	IsAlpha() const;
-	bool	IsZSort() const;
+	bool					IsAlpha() const;
+	bool					IsZSort() const;
 		
-	static void	StartFrame();
-	static void EndFrame();
-
-	void	SetMeshSlot(KX_MeshSlot& ms);
-	void	RemoveMeshSlot(KX_MeshSlot& ms);
-	void	MarkVisibleMeshSlot(KX_MeshSlot& ms,
-								bool visible,
-								bool color,
-								const MT_Vector4& rgbavec);
-
-	void RenderMeshSlot(const MT_Transform& cameratrans, RAS_IRasterizer* rasty,
-		RAS_IRenderTools* rendertools, const KX_MeshSlot &ms, RAS_IRasterizer::DrawMode drawmode);
+	/* Rendering */
 	bool ActivateMaterial(const MT_Transform& cameratrans, RAS_IRasterizer* rasty,
-		RAS_IRenderTools *rendertools, RAS_IRasterizer::DrawMode& drawmode);
-	
-	unsigned int NumMeshSlots();
-	T_MeshSlotList::iterator msBegin();
-	T_MeshSlotList::iterator msEnd();
-
-	struct less
-	{
-		bool operator()(const RAS_MaterialBucket* x, const RAS_MaterialBucket* y) const 
-		{ 
-			return *x->GetPolyMaterial() < *y->GetPolyMaterial(); 
-		}
-	};
+		RAS_IRenderTools *rendertools);
+	void RenderMeshSlot(const MT_Transform& cameratrans, RAS_IRasterizer* rasty,
+		RAS_IRenderTools* rendertools, RAS_MeshSlot &ms);
 	
-	typedef set<RAS_MaterialBucket*, less> Set;
+	/* Mesh Slot Access */
+	list<RAS_MeshSlot>::iterator msBegin();
+	list<RAS_MeshSlot>::iterator msEnd();
+
+	class RAS_MeshSlot*	AddMesh(int numverts);
+	class RAS_MeshSlot* CopyMesh(class RAS_MeshSlot *ms);
+	void				RemoveMesh(class RAS_MeshSlot* ms);
+	void				Optimize(MT_Scalar distance);
+
 private:
-	
-	T_MeshSlotList				m_meshSlots;
-	bool						m_bModified;
+	list<RAS_MeshSlot>			m_meshSlots;
 	RAS_IPolyMaterial*			m_material;
-	double*						m_pOGLMatrix;
 	
 };
 
-#endif //__KX_BUCKET
+#endif //__RAS_MATERIAL_BUCKET
 
diff --git a/source/gameengine/Rasterizer/RAS_MeshObject.cpp b/source/gameengine/Rasterizer/RAS_MeshObject.cpp
index a4f7f3f01dd..a907994bf57 100644
--- a/source/gameengine/Rasterizer/RAS_MeshObject.cpp
+++ b/source/gameengine/Rasterizer/RAS_MeshObject.cpp
@@ -26,10 +26,6 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include "RAS_MeshObject.h"
 #include "RAS_IRasterizer.h"
 #include "MT_MinMax.h"
@@ -37,62 +33,84 @@
 
 #include <algorithm>
 
+/* polygon sorting */
 
-STR_String RAS_MeshObject::s_emptyname = "";
+struct RAS_MeshObject::polygonSlot
+{
+	float m_z;
+	int m_index[4];
+	
+	polygonSlot() {}
 
+	/* pnorm is the normal from the plane equation that the distance from is
+	 * used to sort again. */
+	void get(const RAS_TexVert *vertexarray, const unsigned short *indexarray,
+		int offset, int nvert, const MT_Vector3& pnorm)
+	{
+		MT_Vector3 center(0, 0, 0);
+		int i;
 
+		for(i=0; i<nvert; i++) {
+			m_index[i] = indexarray[offset+i];
+			center += vertexarray[m_index[i]].getXYZ();
+		}
 
-KX_ArrayOptimizer::~KX_ArrayOptimizer()
-{
-	for (vector<KX_VertexArray*>::iterator itv = m_VertexArrayCache1.begin();
-	!(itv == m_VertexArrayCache1.end());++itv)
-	{
-		delete (*itv);
+		/* note we don't divide center by the number of vertices, since all
+		 * polygons have the same number of vertices, and that we leave out
+		 * the 4-th component of the plane equation since it is constant. */
+		m_z = MT_dot(pnorm, center);
 	}
 
-	for (vector<KX_IndexArray*>::iterator iti = m_IndexArrayCache1.begin();
-	!(iti == m_IndexArrayCache1.end());++iti)
+	void set(unsigned short *indexarray, int offset, int nvert)
 	{
-		delete (*iti);
+		int i;
+
+		for(i=0; i<nvert; i++)
+			indexarray[offset+i] = m_index[i];
 	}
+};
 	
-	m_TriangleArrayCount.clear();
-	m_VertexArrayCache1.clear();
-	m_IndexArrayCache1.clear();
-
+struct RAS_MeshObject::backtofront
+{
+	bool operator()(const polygonSlot &a, const polygonSlot &b) const
+	{
+		return a.m_z < b.m_z;
+	}
+};
 
-}
+struct RAS_MeshObject::fronttoback
+{
+	bool operator()(const polygonSlot &a, const polygonSlot &b) const
+	{
+		return a.m_z > b.m_z;
+	}
+};
 
+/* mesh object */
 
+STR_String RAS_MeshObject::s_emptyname = "";
 
 RAS_MeshObject::RAS_MeshObject(Mesh* mesh, int lightlayer)
-	: m_bModified(true),
-	m_lightlayer(lightlayer),
-	m_zsort(false),
-	m_MeshMod(true),
+	: m_lightlayer(lightlayer),
+	m_bModified(true),
+	m_bMeshModified(true),
 	m_mesh(mesh),
-	m_class(0)
+	m_bDeformed(false)
 {
 }
 
-
-bool RAS_MeshObject::MeshModified()
-{
-	return m_MeshMod;
-}
-
-	
 RAS_MeshObject::~RAS_MeshObject()
 {
-	for (vector<RAS_Polygon*>::iterator it=m_Polygons.begin();!(it==m_Polygons.end());it++)
-	{
-		delete (*it);
-	}
+	vector<RAS_Polygon*>::iterator it;
 
-	ClearArrayData();
+	for(it=m_Polygons.begin(); it!=m_Polygons.end(); it++)
+		delete (*it);
 }
 
-
+bool RAS_MeshObject::MeshModified()
+{
+	return m_bMeshModified;
+}
 
 unsigned int RAS_MeshObject::GetLightLayer()
 {
@@ -108,18 +126,21 @@ int RAS_MeshObject::NumMaterials()
 
 const STR_String& RAS_MeshObject::GetMaterialName(unsigned int matid)
 { 
-	RAS_MaterialBucket* bucket = GetMaterialBucket(matid);
+	RAS_MeshMaterial* mmat = GetMeshMaterial(matid);
+
+	if(mmat)
+		return mmat->m_bucket->GetPolyMaterial()->GetMaterialName();
 	
-	return bucket?bucket->GetPolyMaterial()->GetMaterialName():s_emptyname;
+	return s_emptyname;
 }
 
-RAS_MaterialBucket* RAS_MeshObject::GetMaterialBucket(unsigned int matid)
+RAS_MeshMaterial* RAS_MeshObject::GetMeshMaterial(unsigned int matid)
 {
 	if (m_materials.size() > 0 && (matid < m_materials.size()))
 	{
-		RAS_MaterialBucket::Set::const_iterator it = m_materials.begin();
+		list<RAS_MeshMaterial>::iterator it = m_materials.begin();
 		while (matid--) ++it;
-		return *it;
+		return &*it;
 	}
 
 	return NULL;
@@ -141,14 +162,17 @@ RAS_Polygon* RAS_MeshObject::GetPolygon(int num) const
 
 	
 	
-RAS_MaterialBucket::Set::iterator RAS_MeshObject::GetFirstMaterial()
+
+	list<RAS_MeshMaterial>::iterator GetFirstMaterial();
+	list<RAS_MeshMaterial>::iterator GetLastMaterial();
+list<RAS_MeshMaterial>::iterator RAS_MeshObject::GetFirstMaterial()
 {
 	return m_materials.begin();
 }
 
 
 
-RAS_MaterialBucket::Set::iterator RAS_MeshObject::GetLastMaterial()
+list<RAS_MeshMaterial>::iterator RAS_MeshObject::GetLastMaterial()
 {
 	return m_materials.end();
 }
@@ -171,377 +195,238 @@ const STR_String& RAS_MeshObject::GetName()
 
 const STR_String& RAS_MeshObject::GetTextureName(unsigned int matid)
 { 
-	RAS_MaterialBucket* bucket = GetMaterialBucket(matid);
+	RAS_MeshMaterial* mmat = GetMeshMaterial(matid);
 	
-	return bucket?bucket->GetPolyMaterial()->GetTextureName():s_emptyname;
+	if(mmat)
+		return mmat->m_bucket->GetPolyMaterial()->GetTextureName();
+
+	return s_emptyname;
 }
 
+RAS_MeshMaterial *RAS_MeshObject::GetMeshMaterial(RAS_IPolyMaterial *mat)
+{
+	list<RAS_MeshMaterial>::iterator mit;
 
+	/* find a mesh material */
+	for(mit = m_materials.begin(); mit != m_materials.end(); mit++)
+		if(mit->m_bucket->GetPolyMaterial() == mat)
+			return &*mit;
 
-void RAS_MeshObject::AddPolygon(RAS_Polygon* poly)
-{
-	m_Polygons.push_back(poly);
+	return NULL;
 }
 
+RAS_Polygon* RAS_MeshObject::AddPolygon(RAS_MaterialBucket *bucket, int numverts)
+{
+	RAS_MeshMaterial *mmat;
+	RAS_Polygon *poly;
+	RAS_MeshSlot *slot;
 
+	/* find a mesh material */
+	mmat = GetMeshMaterial(bucket->GetPolyMaterial());
+
+	/* none found, create a new one */
+	if(!mmat) {
+		RAS_MeshMaterial meshmat;
+		meshmat.m_bucket = bucket;
+		meshmat.m_baseslot = meshmat.m_bucket->AddMesh(numverts);
+		m_materials.push_back(meshmat);
+		mmat = &m_materials.back();
+	}
+
+	/* add it to the bucket, this also adds new display arrays */
+	slot = mmat->m_baseslot;
+	slot->AddPolygon(numverts);
+
+	/* create a new polygon */
+	RAS_DisplayArray *darray = slot->CurrentDisplayArray();
+	poly = new RAS_Polygon(bucket, darray, numverts);
+	m_Polygons.push_back(poly);
+
+	return poly;
+}
 
 void RAS_MeshObject::DebugColor(unsigned int abgr)
 {
-/*
-	int numpolys = NumPolygons();
-	for (int i=0;i<numpolys;i++)
-	{
+	/*int numpolys = NumPolygons();
+
+	for (int i=0;i<numpolys;i++) {
 		RAS_Polygon* poly = m_polygons[i];
 		for (int v=0;v<poly->VertexCount();v++)
-		{
-		RAS_TexVert* vtx = poly->GetVertex(v);
-		vtx->setDebugRGBA(abgr);
-		}
+			RAS_TexVert* vtx = poly->GetVertex(v)->setDebugRGBA(abgr);
 	}
 	*/
 
-	m_debugcolor = abgr;	
+	/* m_debugcolor = abgr;	*/
 }
 
 void RAS_MeshObject::SetVertexColor(RAS_IPolyMaterial* mat,MT_Vector4 rgba)
 {
-	const vecVertexArray & vertexvec = GetVertexCache(mat);
-			
-	for (vector<KX_VertexArray*>::const_iterator it = vertexvec.begin(); it != vertexvec.end(); ++it)
-	{
-		KX_VertexArray::iterator vit;
-		for (vit=(*it)->begin(); vit != (*it)->end(); vit++)
-		{
-			vit->SetRGBA(rgba);
-		}
-	}	
-}
-
-void RAS_MeshObject::SchedulePoly(const KX_VertexIndex& idx,
-								  int numverts,
-								  RAS_IPolyMaterial* mat)
-{
-	KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);
-
-	ao->m_IndexArrayCache1[idx.m_vtxarray]->push_back(idx.m_indexarray[0]);
-	ao->m_IndexArrayCache1[idx.m_vtxarray]->push_back(idx.m_indexarray[1]);
-	ao->m_IndexArrayCache1[idx.m_vtxarray]->push_back(idx.m_indexarray[2]);
-
-	if (!mat->UsesTriangles())
-		ao->m_IndexArrayCache1[idx.m_vtxarray]->push_back(idx.m_indexarray[3]);
-}
+	RAS_MeshMaterial *mmat = GetMeshMaterial(mat);
+	RAS_MeshSlot *slot = mmat->m_baseslot;
+	RAS_MeshSlot::iterator it;
+	size_t i;
+
+	for(slot->begin(it); !slot->end(it); slot->next(it))
+		for(i=it.startvertex; i<it.endvertex; i++)
+			it.vertex[i].SetRGBA(rgba);
+}
+
+void RAS_MeshObject::AddVertex(RAS_Polygon *poly, int i,
+								const MT_Point3& xyz,
+								const MT_Point2& uv,
+								const MT_Point2& uv2,
+								const MT_Vector4& tangent,
+								const unsigned int rgba,
+								const MT_Vector3& normal,
+								bool flat,
+								int origindex)
+{
+	RAS_TexVert texvert(xyz, uv, uv2, tangent, rgba, normal, flat, origindex);
+	RAS_MeshMaterial *mmat;
+	RAS_DisplayArray *darray;
+	RAS_MeshSlot *slot;
+	int offset;
+	
+	mmat = GetMeshMaterial(poly->GetMaterial()->GetPolyMaterial());
+	slot = mmat->m_baseslot;
+	darray = slot->CurrentDisplayArray();
 
+	if(!flat) {
+		/* find vertices shared between faces, with the restriction
+		 * that they exist in the same display array, and have the
+		 * same uv coordinate etc */
+		vector<SharedVertex>& sharedmap = m_sharedvertex_map[origindex];
+		vector<SharedVertex>::iterator it;
 
-void RAS_MeshObject::ScheduleWireframePoly(const KX_VertexIndex& idx,
-										   int numverts,
-										   int edgecode,
-										   RAS_IPolyMaterial* mat)
-{
-	//int indexpos = m_IndexArrayCount[idx.m_vtxarray];
-	int edgetrace = 1<<(numverts-1);
-	bool drawedge = (edgecode & edgetrace)!=0;
-	edgetrace = 1;
-	int prevvert = idx.m_indexarray[numverts-1];
-	KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);
-	
-	for (int v = 0; v < numverts; v++)
-	{
-		unsigned int curvert = idx.m_indexarray[v];
-		if (drawedge)
+		for(it = sharedmap.begin(); it != sharedmap.end(); it++)
 		{
-			ao->m_IndexArrayCache1[idx.m_vtxarray]->push_back(prevvert);
-			ao->m_IndexArrayCache1[idx.m_vtxarray]->push_back(curvert);
+			if(it->m_darray != darray)
+				continue;
+			if(!it->m_darray->m_vertex[it->m_offset].closeTo(&texvert))
+				continue;
+
+			/* found one, add it and we're done */
+			if(poly->IsVisible())
+				slot->AddPolygonVertex(it->m_offset);
+			poly->SetVertexOffset(i, it->m_offset);
+			return;
 		}
-		prevvert = curvert;
-		drawedge = (edgecode & edgetrace)!=0;
-		edgetrace*=2;
 	}
-	//m_IndexArrayCount[idx.m_vtxarray] = indexpos;
-}
 
-int RAS_MeshObject::FindOrAddVertex(int vtxarray,
-									const MT_Point3& xyz,
-									const MT_Point2& uv,
-									const MT_Point2& uv2,
-									const MT_Vector4& tangent,
-									const unsigned int rgbacolor,
-									const MT_Vector3& normal,
-									bool flat,
-									RAS_IPolyMaterial* mat,
-									int origindex)
-{
-	KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);
-	
-	int numverts = ao->m_VertexArrayCache1[vtxarray]->size();//m_VertexArrayCount[vtxarray];
-	RAS_TexVert newvert(xyz,uv,uv2,tangent,rgbacolor,normal, flat? TV_CALCFACENORMAL: 0,origindex);
+	/* no shared vertex found, add a new one */
+	offset = slot->AddVertex(texvert);
+	if(poly->IsVisible())
+		slot->AddPolygonVertex(offset);
+	poly->SetVertexOffset(i, offset);
 
-#define KX_FIND_SHARED_VERTICES
-#ifdef KX_FIND_SHARED_VERTICES
 	if(!flat) {
-		for (std::vector<RAS_MatArrayIndex>::iterator it = m_xyz_index_to_vertex_index_mapping[origindex].begin();
-			 it != m_xyz_index_to_vertex_index_mapping[origindex].end();
-			 it++)
-		{
-			if ((*it).m_arrayindex1 == ao->m_index1 &&
-				(*it).m_array == vtxarray && 
-				*(*it).m_matid == *mat &&
-				(*ao->m_VertexArrayCache1[vtxarray])[(*it).m_index].closeTo(&newvert)
-				)
-			{
-				return (*it).m_index;
-			}
-		}
+		SharedVertex shared;
+		shared.m_darray = darray;
+		shared.m_offset = offset;
+		m_sharedvertex_map[origindex].push_back(shared);
 	}
-#endif // KX_FIND_SHARED_VERTICES
-	
-	// no vertex found, add one
-	ao->m_VertexArrayCache1[vtxarray]->push_back(newvert);
-	//	printf("(%f,%f,%f) ",xyz[0],xyz[1],xyz[2]);
-	RAS_MatArrayIndex idx;
-	idx.m_arrayindex1 = ao->m_index1;
-	idx.m_array = vtxarray;
-	idx.m_index = numverts;
-	idx.m_matid = mat;
-	m_xyz_index_to_vertex_index_mapping[origindex].push_back(idx); 
-	
-	return numverts;
 }
 
-vecVertexArray& RAS_MeshObject::GetVertexCache (RAS_IPolyMaterial* mat)
+int RAS_MeshObject::NumVertices(RAS_IPolyMaterial* mat)
 {
-	KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);
-
-	return ao->m_VertexArrayCache1;
-}
+	RAS_MeshMaterial *mmat;
+	RAS_MeshSlot *slot;
+	RAS_MeshSlot::iterator it;
+	size_t len = 0;
 
-int RAS_MeshObject::GetVertexArrayLength(RAS_IPolyMaterial* mat)
-{
-	int len = 0;
-
-	const vecVertexArray & vertexvec = GetVertexCache(mat);
-	vector<KX_VertexArray*>::const_iterator it = vertexvec.begin();
+	mmat = GetMeshMaterial(mat);
+	slot = mmat->m_baseslot;
+	for(slot->begin(it); !slot->end(it); slot->next(it))
+		len += it.endvertex - it.startvertex;
 	
-	for (; it != vertexvec.end(); ++it)
-	{
-		len += (*it)->size();
-	}
-
 	return len;
 }
 
-	
 
 RAS_TexVert* RAS_MeshObject::GetVertex(unsigned int matid,
 									   unsigned int index)
 {
-	RAS_TexVert* vertex = NULL;
-	
-	RAS_MaterialBucket* bucket = GetMaterialBucket(matid);
-	if (bucket)
-	{
-		RAS_IPolyMaterial* mat = bucket->GetPolyMaterial();
-		if (mat)
-		{
-			const vecVertexArray & vertexvec = GetVertexCache(mat);
-			vector<KX_VertexArray*>::const_iterator it = vertexvec.begin();
-			
-			for (unsigned int len = 0; it != vertexvec.end(); ++it)
-			{
-				if (index < len + (*it)->size())
-				{
-					vertex = &(*(*it))[index-len];
-					break;
-				}
-				else
-				{
-					len += (*it)->size();
-				}
-			}
-		}
-	}
-	
-	return vertex;
-}
-
-
+	RAS_MeshMaterial *mmat;
+	RAS_MeshSlot *slot;
+	RAS_MeshSlot::iterator it;
+	size_t len;
 
-const vecIndexArrays& RAS_MeshObject::GetIndexCache (RAS_IPolyMaterial* mat)
-{
-	KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);
-
-	return ao->m_IndexArrayCache1;
-}
+	mmat = GetMeshMaterial(matid);
 
-
-
-KX_ArrayOptimizer* RAS_MeshObject::GetArrayOptimizer(RAS_IPolyMaterial* polymat)
-{
-	KX_ArrayOptimizer** aop = m_matVertexArrayS[polymat];
-
-	if(aop)
-		return *aop;
+	if(!mmat)
+		return NULL;
 	
-	// didn't find array, but an array might already exist
-	// for a material equal to this one
-	for(int i=0;i<m_matVertexArrayS.size();i++) {
-		RAS_IPolyMaterial *mat = (RAS_IPolyMaterial*)(m_matVertexArrayS.getKey(i)->getValue());
-		if(*mat == *polymat) {
-			m_matVertexArrayS.insert(polymat, *m_matVertexArrayS.at(i));
-			return *m_matVertexArrayS.at(i);
-		}
+	slot = mmat->m_baseslot;
+	len = 0;
+	for(slot->begin(it); !slot->end(it); slot->next(it)) {
+		if(index >= len + it.endvertex - it.startvertex)
+			len += it.endvertex - it.startvertex;
+		else
+			return &it.vertex[index - len];
 	}
-
-	// create new array
-	int numelements = m_matVertexArrayS.size();
-	m_sortedMaterials.push_back(polymat);
-
-	KX_ArrayOptimizer* ao = new KX_ArrayOptimizer(numelements);
-	m_matVertexArrayS.insert(polymat, ao);
 	
-	return ao;
+	return NULL;
 }
 
-
-
-void RAS_MeshObject::Bucketize(double* oglmatrix,
-							   void* clientobj,
-							   bool useObjectColor,
-							   const MT_Vector4& rgbavec)
+void RAS_MeshObject::AddMeshUser(void *clientobj)
 {
-	KX_MeshSlot ms;
-	ms.m_clientObj = clientobj;
-	ms.m_mesh = this;
-	ms.m_OpenGLMatrix = oglmatrix;
-	ms.m_bObjectColor = useObjectColor;
-	ms.m_RGBAcolor = rgbavec;
-	
-	for (RAS_MaterialBucket::Set::iterator it = m_materials.begin();it!=m_materials.end();++it)
-	{
-		RAS_MaterialBucket* bucket = *it;
-//		KX_ArrayOptimizer* oa = GetArrayOptimizer(bucket->GetPolyMaterial());
-		bucket->SetMeshSlot(ms);
-	}
+	list<RAS_MeshMaterial>::iterator it;
 
-}
-
-
-
-void RAS_MeshObject::MarkVisible(double* oglmatrix,
-								 void* clientobj,
-								 bool visible,
-								 bool useObjectColor,
-								 const MT_Vector4& rgbavec)
-{
-	KX_MeshSlot ms;
-	ms.m_clientObj = clientobj;
-	ms.m_mesh = this;
-	ms.m_OpenGLMatrix = oglmatrix;
-	ms.m_RGBAcolor = rgbavec;
-	ms.m_bObjectColor= useObjectColor;
-
-	for (RAS_MaterialBucket::Set::iterator it = m_materials.begin();it!=m_materials.end();++it)
-	{
-		RAS_MaterialBucket* bucket = *it;
-//		KX_ArrayOptimizer* oa = GetArrayOptimizer(bucket->GetPolyMaterial());
-		bucket->MarkVisibleMeshSlot(ms,visible,useObjectColor,rgbavec);
+	for(it = m_materials.begin();it!=m_materials.end();++it) {
+		/* always copy from the base slot, which is never removed 
+		 * since new objects can be created with the same mesh data */
+		RAS_MeshSlot *ms = it->m_bucket->CopyMesh(it->m_baseslot);
+		ms->m_clientObj = clientobj;
+		it->m_slots.insert(clientobj, ms);
 	}
 }
 
-
-void RAS_MeshObject::RemoveFromBuckets(double* oglmatrix,
-									   void* clientobj)
+void RAS_MeshObject::UpdateBuckets(void* clientobj,
+							   double* oglmatrix,
+							   bool useObjectColor,
+							   const MT_Vector4& rgbavec,
+							   bool visible,
+							   bool culled)
 {
-	KX_MeshSlot ms;
-	ms.m_clientObj = clientobj;
-	ms.m_mesh = this;
-	ms.m_OpenGLMatrix = oglmatrix;
-
-	for (RAS_MaterialBucket::Set::iterator it = m_materials.begin();it!=m_materials.end();++it)
-	{
-		RAS_MaterialBucket* bucket = *it;
-//		RAS_IPolyMaterial* polymat = bucket->GetPolyMaterial();
-		//KX_ArrayOptimizer* oa = GetArrayOptimizer(polymat);
-		bucket->RemoveMeshSlot(ms);
-	}
-
-}
-
-
+	list<RAS_MeshMaterial>::iterator it;
 
-/*
- * RAS_MeshObject::GetVertex returns the vertex located somewhere in the vertexpool
- * it is the clients responsibility to make sure the array and index are valid
- */
-RAS_TexVert* RAS_MeshObject::GetVertex(short array,
-									   unsigned int index,
-									   RAS_IPolyMaterial* polymat)
-{
-	 KX_ArrayOptimizer* ao = GetArrayOptimizer(polymat);
-	return &((*(ao->m_VertexArrayCache1)[array])[index]);
-}
+	for(it = m_materials.begin();it!=m_materials.end();++it) {
+		RAS_MeshSlot **msp = it->m_slots[clientobj];
 
+		if(!msp)
+			continue;
 
+		RAS_MeshSlot *ms = *msp;
 
-void RAS_MeshObject::ClearArrayData()
-{
-	for (int i=0;i<m_matVertexArrayS.size();i++) {
-		KX_ArrayOptimizer** ao = m_matVertexArrayS.at(i);
-
-		// we have duplicate entries, only free once
-		for(int j=i+1;j<m_matVertexArrayS.size();j++) {
-			if(ao == m_matVertexArrayS.at(j)) {
-				ao = NULL;
-				break;
-			}
-		}
+		ms->m_mesh = this;
+		ms->m_OpenGLMatrix = oglmatrix;
+		ms->m_bObjectColor = useObjectColor;
+		ms->m_RGBAcolor = rgbavec;
+		ms->m_bVisible = visible;
+		ms->m_bCulled = culled || !visible;
 
-		if (ao)
-			delete *ao;
+		/* split if necessary */
+		ms->Split();
 	}
 }
 
-
-
-/**
- * RAS_MeshObject::CreateNewVertices creates vertices within sorted pools of vertices that share same material
-*/
-int	RAS_MeshObject::FindVertexArray(int numverts,
-									RAS_IPolyMaterial* polymat)
+void RAS_MeshObject::RemoveFromBuckets(void *clientobj)
 {
-//	bool found=false;
-	int array=-1;
+	list<RAS_MeshMaterial>::iterator it;
 	
-	KX_ArrayOptimizer* ao = GetArrayOptimizer(polymat);
+	for(it = m_materials.begin();it!=m_materials.end();++it) {
+		RAS_MeshSlot **msp = it->m_slots[clientobj];
 
-	for (unsigned int i=0;i<ao->m_VertexArrayCache1.size();i++)
-	{
-		if ( (ao->m_TriangleArrayCount[i] + (numverts-2)) < BUCKET_MAX_TRIANGLES) 
-		{
-			if((ao->m_VertexArrayCache1[i]->size()+numverts < BUCKET_MAX_INDICES))
-			{
-				array = i;
-				ao->m_TriangleArrayCount[array]+=numverts-2;
-				break;
-			}
-		}
-	}
+		if(!msp)
+			continue;
 
-	if (array == -1)
-	{
-		array = ao->m_VertexArrayCache1.size();
-		vector<RAS_TexVert>* va = new vector<RAS_TexVert>;
-		ao->m_VertexArrayCache1.push_back(va);
-		KX_IndexArray *ia = new KX_IndexArray();
-		ao->m_IndexArrayCache1.push_back(ia);
-		ao->m_TriangleArrayCount.push_back(numverts-2);
-	}
+		RAS_MeshSlot *ms = *msp;
 
-	return array;
+		it->m_bucket->RemoveMesh(ms);
+		it->m_slots.remove(clientobj);
+	}
 }
 
-
-
-
 //void RAS_MeshObject::Transform(const MT_Transform& trans)
 //{
 	//m_trans.translate(MT_Vector3(0,0,1));//.operator *=(trans);
@@ -563,71 +448,7 @@ void RAS_MeshObject::RelativeTransform(const MT_Vector3& vec)
 }
 */
 
-
-
-void RAS_MeshObject::UpdateMaterialList()
-{
-	m_materials.clear();
-	unsigned int numpolys = m_Polygons.size();
-	// for all polygons, find out which material they use, and add it to the set of materials
-	for (unsigned int i=0;i<numpolys;i++)
-	{
-		m_materials.insert(m_Polygons[i]->GetMaterial());
-	}
-}
-
-struct RAS_MeshObject::polygonSlot
-{
-	float m_z;
-	int m_index[4];
-	
-	polygonSlot() {}
-
-	/* pnorm is the normal from the plane equation that the distance from is
-	 * used to sort again. */
-	void get(const KX_VertexArray& vertexarray, const KX_IndexArray& indexarray,
-		int offset, int nvert, const MT_Vector3& pnorm)
-	{
-		MT_Vector3 center(0, 0, 0);
-		int i;
-
-		for(i=0; i<nvert; i++) {
-			m_index[i] = indexarray[offset+i];
-			center += vertexarray[m_index[i]].getLocalXYZ();
-		}
-
-		/* note we don't divide center by the number of vertices, since all
-		 * polygons have the same number of vertices, and that we leave out
-		 * the 4-th component of the plane equation since it is constant. */
-		m_z = MT_dot(pnorm, center);
-	}
-
-	void set(KX_IndexArray& indexarray, int offset, int nvert)
-	{
-		int i;
-
-		for(i=0; i<nvert; i++)
-			indexarray[offset+i] = m_index[i];
-	}
-};
-	
-struct RAS_MeshObject::backtofront
-{
-	bool operator()(const polygonSlot &a, const polygonSlot &b) const
-	{
-		return a.m_z < b.m_z;
-	}
-};
-
-struct RAS_MeshObject::fronttoback
-{
-	bool operator()(const polygonSlot &a, const polygonSlot &b) const
-	{
-		return a.m_z > b.m_z;
-	}
-};
-
-void RAS_MeshObject::SortPolygons(const MT_Transform &transform)
+void RAS_MeshObject::SortPolygons(RAS_MeshSlot& ms, const MT_Transform &transform)
 {
 	// Limitations: sorting is quite simple, and handles many
 	// cases wrong, partially due to polygons being sorted per
@@ -645,43 +466,34 @@ void RAS_MeshObject::SortPolygons(const MT_Transform &transform)
 	// to avoid excessive state changes while drawing. e) would
 	// require splitting polygons.
 
-	if (!m_zsort)
-		return;
+	RAS_MeshSlot::iterator it;
+	size_t j;
 
-	// Extract camera Z plane...
-	const MT_Vector3 pnorm(transform.getBasis()[2]);
-	// unneeded: const MT_Scalar pval = transform.getOrigin()[2];
+	for(ms.begin(it); !ms.end(it); ms.next(it)) {
+		unsigned int nvert = (int)it.array->m_type;
+		unsigned int totpoly = it.totindex/nvert;
 
-	for (RAS_MaterialBucket::Set::iterator it = m_materials.begin();it!=m_materials.end();++it)
-	{
-		if(!(*it)->IsZSort())
+		if(totpoly <= 1)
+			continue;
+		if(it.array->m_type == RAS_DisplayArray::LINE)
 			continue;
 
-		RAS_IPolyMaterial *mat = (*it)->GetPolyMaterial();
-		KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);
-
-		vecIndexArrays& indexarrays = ao->m_IndexArrayCache1;
-		vecVertexArray& vertexarrays = ao->m_VertexArrayCache1;
-		unsigned int i, j, nvert = (mat->UsesTriangles())? 3: 4;
-
-		for(i=0; i<indexarrays.size(); i++) {
-			KX_IndexArray& indexarray = *indexarrays[i];
-			KX_VertexArray& vertexarray = *vertexarrays[i];
+		// Extract camera Z plane...
+		const MT_Vector3 pnorm(transform.getBasis()[2]);
+		// unneeded: const MT_Scalar pval = transform.getOrigin()[2];
 
-			unsigned int totpoly = indexarray.size()/nvert;
-			vector<polygonSlot> slots(totpoly);
+		vector<polygonSlot> slots(totpoly);
 
-			/* get indices and z into temporary array */
-			for(j=0; j<totpoly; j++)
-				slots[j].get(vertexarray, indexarray, j*nvert, nvert, pnorm);
+		/* get indices and z into temporary array */
+		for(j=0; j<totpoly; j++)
+			slots[j].get(it.vertex, it.index, j*nvert, nvert, pnorm);
 
-			/* sort (stable_sort might be better, if flickering happens?) */
-			std::sort(slots.begin(), slots.end(), backtofront());
+		/* sort (stable_sort might be better, if flickering happens?) */
+		std::sort(slots.begin(), slots.end(), backtofront());
 
-			/* get indices from temporary array again */
-			for(j=0; j<totpoly; j++)
-				slots[j].set(indexarray, j*nvert, nvert);
-		}
+		/* get indices from temporary array again */
+		for(j=0; j<totpoly; j++)
+			slots[j].set(it.index, j*nvert, nvert);
 	}
 }
 
@@ -690,37 +502,8 @@ void RAS_MeshObject::SchedulePolygons(int drawingmode)
 {
 	if (m_bModified)
 	{
-		int i, numpolys = m_Polygons.size();
-
-		for (RAS_MaterialBucket::Set::iterator it = m_materials.begin();it!=m_materials.end();++it)
-			if ((*it)->IsZSort())
-				m_zsort = true;
-		
-		if (drawingmode == RAS_IRasterizer::KX_WIREFRAME)
-		{
-			for (i=0;i<numpolys;i++)
-			{
-				RAS_Polygon* poly = m_Polygons[i];
-				if (poly->IsVisible())
-					ScheduleWireframePoly(poly->GetVertexIndexBase(),poly->VertexCount(),poly->GetEdgeCode(),
-						poly->GetMaterial()->GetPolyMaterial());
-				
-			}
-			m_zsort = false;
-		}
-		else
-		{
-			for (i=0;i<numpolys;i++)
-			{
-				RAS_Polygon* poly = m_Polygons[i];
-				if (poly->IsVisible())
-					SchedulePoly(poly->GetVertexIndexBase(),poly->VertexCount(),
-						poly->GetMaterial()->GetPolyMaterial());
-			}
-		}
-
 		m_bModified = false;
-		m_MeshMod = true;
+		m_bMeshModified = true;
 	} 
 }
 
diff --git a/source/gameengine/Rasterizer/RAS_MeshObject.h b/source/gameengine/Rasterizer/RAS_MeshObject.h
index 9a46d89c393..0d35a2f402b 100644
--- a/source/gameengine/Rasterizer/RAS_MeshObject.h
+++ b/source/gameengine/Rasterizer/RAS_MeshObject.h
@@ -36,6 +36,7 @@
 
 #include <vector>
 #include <set>
+#include <list>
 
 #include "RAS_Polygon.h"
 #include "RAS_MaterialBucket.h"
@@ -44,194 +45,71 @@
 #include "GEN_HashedPtr.h"
 
 struct Mesh;
-/**
- * This class holds an array of vertices and indicies.
- */
-class KX_ArrayOptimizer
-{
-public:
-	KX_ArrayOptimizer(int index) 
-		: m_index1(index)
-	{};
-	virtual ~KX_ArrayOptimizer();
-	
-	vector<KX_VertexArray*>		m_VertexArrayCache1;
-	vector<int>					m_TriangleArrayCount;
-	vector<KX_IndexArray*>		m_IndexArrayCache1;
 
-	/**
-		order in which they are stored into the mesh
-	*/
-	int							m_index1;
-};
+/* RAS_MeshObject is a mesh used for rendering. It stores polygons,
+ * but the actual vertices and index arrays are stored in material
+ * buckets, referenced by the list of RAS_MeshMaterials. */
 
-/**
- * This struct holds a triangle.
- */
-struct	RAS_TriangleIndex
-{
-public:
-	int	m_index[3];
-	int	m_array;
-	RAS_IPolyMaterial*	m_matid;
-	bool	m_collider;
-};
-
-/**
- * This class looks horribly broken.  Only m_matid is used, and
- * m_matid is a (int) RAS_IPolyMaterial*.  
- * --> m_matid == lhs.m_matid should be *m_matid == *lhs.m_matid
- */
-class	RAS_MatArrayIndex
-{
-public:
-
-	int	m_arrayindex1;
-	RAS_IPolyMaterial*	m_matid;
-	int	m_array;
-	int	m_index;
-
-/*
-	inline bool	Less(const RAS_MatArrayIndex& lhs) const {
-		bool result = 
-			(	(m_matid < lhs.m_matid)		||
-				((m_matid == lhs.m_matid)&&(m_array < lhs.m_array)) ||
-				((m_matid == lhs.m_matid) && (m_array == lhs.m_array) &&
-				(m_index < lhs.m_index))
-					
-			);
-		return result;
-			
-	}
-*/
-	
-};
-/*
-inline  bool operator <( const RAS_MatArrayIndex& rhs,const RAS_MatArrayIndex& lhs)
-{
-	return ( rhs.Less(lhs));
-}*/
-
-/**
- * RAS_MeshObject stores mesh data for the renderer.
- */
 class RAS_MeshObject
 {
-	
-	//	GEN_Map<class RAS_IPolyMaterial,KX_ArrayOptimizer*> m_matVertexArrayS;
-	//vector<class RAS_IPolyMaterial*,KX_ArrayOptimizer> m_vertexArrays;
-	virtual KX_ArrayOptimizer* GetArrayOptimizer(RAS_IPolyMaterial* polymat);
-	//vector<RAS_Polygon*>		m_polygons;
-	
+private:
 	unsigned int				m_debugcolor;
-	bool						m_bModified;
 	int							m_lightlayer;
-	
-	vector<class RAS_Polygon*> 	m_Polygons;
+
+	bool						m_bModified;
+	bool						m_bMeshModified;
+
 	STR_String					m_name;
 	static STR_String			s_emptyname;
-	bool						m_zsort;
-	bool						m_MeshMod;
 
+	vector<class RAS_Polygon*> 	m_Polygons;
+
+	/* polygon sorting */
 	struct polygonSlot;
 	struct backtofront;
 	struct fronttoback;
 
-	void				SchedulePoly(
-							const KX_VertexIndex& idx,
-							int numverts,
-							RAS_IPolyMaterial* mat
-						);
-
-	void				ScheduleWireframePoly(
-							const KX_VertexIndex& idx,
-							int numverts,
-							int edgecode,
-							RAS_IPolyMaterial* mat
-						);
-	
 protected:
-	enum { BUCKET_MAX_INDICES = 65535 };//2048};//8192};
-	enum { BUCKET_MAX_TRIANGLES = 65535 };
-	
-	GEN_Map<GEN_HashedPtr,KX_ArrayOptimizer*> m_matVertexArrayS;
-	
-	RAS_MaterialBucket::Set			m_materials;
+	list<RAS_MeshMaterial>			m_materials;
 	Mesh*							m_mesh;
+	bool							m_bDeformed;
+
 public:
 	// for now, meshes need to be in a certain layer (to avoid sorting on lights in realtime)
 	RAS_MeshObject(Mesh* mesh, int lightlayer);
 	virtual ~RAS_MeshObject();
 
-	vector<RAS_IPolyMaterial*>				m_sortedMaterials;
-	vector<vector<RAS_MatArrayIndex> >		m_xyz_index_to_vertex_index_mapping;
-	vector<RAS_TriangleIndex >				m_triangle_indices;
-	
-	int							m_class;
 
-	unsigned int				GetLightLayer();
+	bool				IsDeformed() { return m_bDeformed; }
+	
+	/* materials */
 	int					NumMaterials();
 	const STR_String&	GetMaterialName(unsigned int matid);
-	RAS_MaterialBucket*	GetMaterialBucket(unsigned int matid);
 	const STR_String&	GetTextureName(unsigned int matid);
-	virtual void		AddPolygon(RAS_Polygon* poly);
-	void				UpdateMaterialList();
-	
-	int					NumPolygons();
-	RAS_Polygon*		GetPolygon(int num) const;
-	
-	virtual void		Bucketize(
-							double* oglmatrix,
-							void* clientobj,
-							bool useObjectColor,
-							const MT_Vector4& rgbavec
-						);
 
-	void				RemoveFromBuckets(
-							double* oglmatrix,
-							void* clientobj
-						);
+	RAS_MeshMaterial* 	GetMeshMaterial(unsigned int matid);
+	RAS_MeshMaterial*	GetMeshMaterial(RAS_IPolyMaterial *mat);
 
-	void				MarkVisible(
-							double* oglmatrix,
-							void* clientobj,
-							bool visible,
-							bool useObjectColor,
-							const MT_Vector4& rgbavec
-						);
+	list<RAS_MeshMaterial>::iterator GetFirstMaterial();
+	list<RAS_MeshMaterial>::iterator GetLastMaterial();
 
-	void				DebugColor(unsigned int abgr);
-	void 				SetVertexColor(RAS_IPolyMaterial* mat,MT_Vector4 rgba);
-	
-	/**
-	 *  Sorts the polygons by their transformed z values.
-	 */
-	void				SortPolygons(const MT_Transform &transform);
+	unsigned int		GetLightLayer();
 
-	void				SchedulePolygons(int drawingmode);
+	/* name */
+	void				SetName(STR_String name);
+	const STR_String&	GetName();
 
-	void				ClearArrayData();
-	
-	RAS_MaterialBucket::Set::iterator GetFirstMaterial();
-	RAS_MaterialBucket::Set::iterator GetLastMaterial();
-	
-	virtual RAS_TexVert*	GetVertex(
-								short array,
-								unsigned int index,
-								RAS_IPolyMaterial* polymat
-							);
-	
-	virtual int			FindVertexArray(
-							int numverts,
-							RAS_IPolyMaterial* polymat
-						);
+	/* modification state */
+	bool				MeshModified();
+	void				SetMeshModified(bool v){m_bMeshModified = v;}
 
+	/* original blender mesh */
+	Mesh*				GetMesh() { return m_mesh; }
+
+	/* mesh construction */
 	
-	// find (and share) or add vertices
-	// for some speedup, only the last 20 added vertices are searched for equality
-	
-	virtual int			FindOrAddVertex(
-							int vtxarray,
+	virtual RAS_Polygon*	AddPolygon(RAS_MaterialBucket *bucket, int numverts);
+	virtual void			AddVertex(RAS_Polygon *poly, int i,
 							const MT_Point3& xyz,
 							const MT_Point2& uv,
 							const MT_Point2& uv2,
@@ -239,27 +117,43 @@ public:
 							const unsigned int rgbacolor,
 							const MT_Vector3& normal,
 							bool flat,
-							RAS_IPolyMaterial* mat,
-							int origindex
-						);
-	
-	vecVertexArray&		GetVertexCache (RAS_IPolyMaterial* mat);
+							int origindex);
+
+	void					SchedulePolygons(int drawingmode);
+
+	/* vertex and polygon acces */
+	int					NumVertices(RAS_IPolyMaterial* mat);
+	RAS_TexVert*		GetVertex(unsigned int matid, unsigned int index);
+
+	int					NumPolygons();
+	RAS_Polygon*		GetPolygon(int num) const;
 	
-	int					GetVertexArrayLength(RAS_IPolyMaterial* mat);
+	/* buckets */
+	virtual void		AddMeshUser(void *clientobj);
+	virtual void		UpdateBuckets(
+							void* clientobj,
+							double* oglmatrix,
+							bool useObjectColor,
+							const MT_Vector4& rgbavec,
+							bool visible,
+							bool culled);
 
-	RAS_TexVert*		GetVertex(
-							unsigned int matid,
-							unsigned int index
-						);
+	void				RemoveFromBuckets(void *clientobj);
 
-	const vecIndexArrays& GetIndexCache (RAS_IPolyMaterial* mat);
-	void				SetName(STR_String name);
-	const STR_String&	GetName();
+	/* colors */
+	void				DebugColor(unsigned int abgr);
+	void 				SetVertexColor(RAS_IPolyMaterial* mat,MT_Vector4 rgba);
+	
+	/* polygon sorting by Z for alpha */
+	void				SortPolygons(RAS_MeshSlot& ms, const MT_Transform &transform);
 
-	bool				MeshModified();
-	void				SetMeshModified(bool v){m_MeshMod = v;}
-	Mesh*				GetMesh() { return m_mesh; }
+	/* for construction to find shared vertices */
+	struct SharedVertex {
+		RAS_DisplayArray *m_darray;
+		int m_offset;
+	};
 
+	vector<vector<SharedVertex> >	m_sharedvertex_map;
 };
 
 #endif //__RAS_MESHOBJECT
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
index 2a6d64ecc73..e4403ace69f 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
@@ -32,6 +32,7 @@ SET(INC
   ../../../../intern/moto/include
   ../../../../source/gameengine/Rasterizer
   ../../../../extern/glew/include
+  ../../../../source/blender/gpu
 )
 
 BLENDERLIB(bf_oglrasterizer "${SRC}" "${INC}")
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/Makefile b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/Makefile
index f01978b8eb1..aee485a22be 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/Makefile
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/Makefile
@@ -41,12 +41,11 @@ CPPFLAGS += -I$(OPENGL_HEADERS)
 CPPFLAGS += -I$(NAN_STRING)/include    
 CPPFLAGS += -I$(NAN_MOTO)/include
 CPPFLAGS += -I../../../kernel/gen_system
+CPPFLAGS += -I../../../blender/gpu
 CPPFLAGS += -I../../BlenderRoutines
 CPPFLAGS += -I..
+
 ifeq ($(OS),darwin)
 	CPPFLAGS += -fpascal-strings
 endif
 
-ifeq ($(WITH_BF_GLEXT),true)
-	CPPFLAGS += -DWITH_GLEXT
-endif
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp
index c2687319717..2c4b55ff964 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp
@@ -9,6 +9,7 @@
 
 #include "GL/glew.h"
 
+#include "RAS_MaterialBucket.h"
 #include "RAS_TexVert.h"
 #include "MT_assert.h"
 
@@ -125,20 +126,20 @@ void RAS_ListRasterizer::RemoveListSlot(RAS_ListSlot* list)
 	}
 }
 
-RAS_ListSlot* RAS_ListRasterizer::FindOrAdd(const vecVertexArray& vertexarrays, KX_ListSlot** slot)
+RAS_ListSlot* RAS_ListRasterizer::FindOrAdd(RAS_MeshSlot& ms)
 {
 	/*
 	 Keep a copy of constant lists submitted for rendering,
 		this guards against (replicated)new...delete every frame,
 		and we can reuse lists!
-		:: sorted by vertex array
+		:: sorted by mesh slot
 	*/
-	RAS_ListSlot* localSlot = (RAS_ListSlot*)*slot;
+	RAS_ListSlot* localSlot = (RAS_ListSlot*)ms.m_DisplayList;
 	if(!localSlot) {
-		RAS_Lists::iterator it = mLists.find(vertexarrays);
+		RAS_Lists::iterator it = mLists.find(&ms);
 		if(it == mLists.end()) {
 			localSlot = new RAS_ListSlot(this);
-			mLists.insert(std::pair<vecVertexArray, RAS_ListSlot*>(vertexarrays, localSlot));
+			mLists.insert(std::pair<RAS_MeshSlot*, RAS_ListSlot*>(&ms, localSlot));
 		} else {
 			localSlot = static_cast<RAS_ListSlot*>(it->second->AddRef());
 		}
@@ -157,69 +158,45 @@ void RAS_ListRasterizer::ReleaseAlloc()
 	mLists.clear();
 }
 
-
-void RAS_ListRasterizer::IndexPrimitives(
-	const vecVertexArray & vertexarrays,
-	const vecIndexArrays & indexarrays,
-	DrawMode mode,
-	bool useObjectColor,
-	const MT_Vector4& rgbacolor,
-	class KX_ListSlot** slot)
+void RAS_ListRasterizer::IndexPrimitives(RAS_MeshSlot& ms)
 {
 	RAS_ListSlot* localSlot =0;
 
-	// useObjectColor(are we updating every frame?)
-	if(!useObjectColor && slot) {
-		localSlot = FindOrAdd(vertexarrays, slot);
+	if(ms.m_bDisplayList) {
+		localSlot = FindOrAdd(ms);
 		localSlot->DrawList();
 		if(localSlot->End()) {
 			// save slot here too, needed for replicas and object using same mesh
 			// => they have the same vertexarray but different mesh slot
-			*slot = localSlot;
+			ms.m_DisplayList = localSlot;
 			return;
 		}
 	}
 	
-	if (mUseVertexArrays) {
-		RAS_VAOpenGLRasterizer::IndexPrimitives(
-				vertexarrays, indexarrays,
-				mode, useObjectColor,
-				rgbacolor,slot
-		);
-	} else {
-		RAS_OpenGLRasterizer::IndexPrimitives(
-				vertexarrays, indexarrays,
-				mode, useObjectColor,
-				rgbacolor,slot
-		);
-	}
+	if (mUseVertexArrays)
+		RAS_VAOpenGLRasterizer::IndexPrimitives(ms);
+	else
+		RAS_OpenGLRasterizer::IndexPrimitives(ms);
 
-	if(!useObjectColor && slot) {
+	if(ms.m_bDisplayList) {
 		localSlot->EndList();
-		*slot = localSlot;
+		ms.m_DisplayList = localSlot;
 	}
 }
 
 
-void RAS_ListRasterizer::IndexPrimitivesMulti(
-		const vecVertexArray& vertexarrays,
-		const vecIndexArrays & indexarrays,
-		DrawMode mode,
-		bool useObjectColor,
-		const MT_Vector4& rgbacolor,
-		class KX_ListSlot** slot)
+void RAS_ListRasterizer::IndexPrimitivesMulti(RAS_MeshSlot& ms)
 {
 	RAS_ListSlot* localSlot =0;
 
-	// useObjectColor(are we updating every frame?)
-	if(!useObjectColor && slot) {
-		localSlot = FindOrAdd(vertexarrays, slot);
+	if(ms.m_bDisplayList) {
+		localSlot = FindOrAdd(ms);
 		localSlot->DrawList();
 
 		if(localSlot->End()) {
 			// save slot here too, needed for replicas and object using same mesh
 			// => they have the same vertexarray but different mesh slot
-			*slot = localSlot;
+			ms.m_DisplayList = localSlot;
 			return;
 		}
 	}
@@ -227,23 +204,14 @@ void RAS_ListRasterizer::IndexPrimitivesMulti(
 	// workaround: note how we do not use vertex arrays for making display
 	// lists, since glVertexAttribPointerARB doesn't seem to work correct
 	// in display lists on ATI? either a bug in the driver or in Blender ..
-	if (mUseVertexArrays && !localSlot) {
-		RAS_VAOpenGLRasterizer::IndexPrimitivesMulti(
-				vertexarrays, indexarrays,
-				mode, useObjectColor,
-				rgbacolor,slot
-		);
-	} else {
-		RAS_OpenGLRasterizer::IndexPrimitivesMulti(
-				vertexarrays, indexarrays,
-				mode, useObjectColor,
-				rgbacolor,slot
-		);
-	}
+	if (mUseVertexArrays && !localSlot)
+		RAS_VAOpenGLRasterizer::IndexPrimitivesMulti(ms);
+	else
+		RAS_OpenGLRasterizer::IndexPrimitivesMulti(ms);
 
-	if(!useObjectColor && slot) {
+	if(ms.m_bDisplayList) {
 		localSlot->EndList();
-		*slot = localSlot;
+		ms.m_DisplayList = localSlot;
 	}
 }
 
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.h
index b1b19144c12..96d6d2a995d 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.h
@@ -4,6 +4,7 @@
 #include "RAS_MaterialBucket.h"
 #include "RAS_VAOpenGLRasterizer.h"
 #include <vector>
+#include <map>
 
 class RAS_ListRasterizer;
 class RAS_ListSlot : public KX_ListSlot
@@ -34,14 +35,14 @@ enum RAS_ListSlotFlags	{
 	LIST_REGEN		=64
 };
 
-typedef std::map<const vecVertexArray, RAS_ListSlot*> RAS_Lists;
+typedef std::map<class RAS_MeshSlot*, RAS_ListSlot*> RAS_Lists;
 
 class RAS_ListRasterizer : public RAS_VAOpenGLRasterizer
 {
 	bool mUseVertexArrays;
 	RAS_Lists mLists;
 
-	RAS_ListSlot* FindOrAdd(const vecVertexArray& vertexarrays, KX_ListSlot** slot);
+	RAS_ListSlot* FindOrAdd(class RAS_MeshSlot& ms);
 	void ReleaseAlloc();
 
 public:
@@ -49,23 +50,8 @@ public:
 	RAS_ListRasterizer(RAS_ICanvas* canvas, bool useVertexArrays=false, bool lock=false);
 	virtual ~RAS_ListRasterizer();
 
-	virtual void IndexPrimitives(
-			const vecVertexArray& vertexarrays,
-			const vecIndexArrays & indexarrays,
-			DrawMode mode,
-			bool useObjectColor,
-			const MT_Vector4& rgbacolor,
-			class KX_ListSlot** slot
-	);
-
-	virtual void IndexPrimitivesMulti(
-			const vecVertexArray& vertexarrays,
-			const vecIndexArrays & indexarrays,
-			DrawMode mode,
-			bool useObjectColor,
-			const MT_Vector4& rgbacolor,
-			class KX_ListSlot** slot
-	);
+	virtual void	IndexPrimitives(class RAS_MeshSlot& ms);
+	virtual void	IndexPrimitivesMulti(class RAS_MeshSlot& ms);
 
 	virtual bool	Init();
 	virtual void	Exit();
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
index 1dcc6e70934..62ee2edb731 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
@@ -38,6 +38,9 @@
 #include "MT_CmMatrix4x4.h"
 #include "RAS_IRenderTools.h" // rendering text
 
+#include "GPU_draw.h"
+#include "GPU_material.h"
+
 /**
  *  32x32 bit masks for vinterlace stereo mode
  */
@@ -67,10 +70,12 @@ RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas)
 	m_motionblurvalue(-1.0),
 	m_texco_num(0),
 	m_attrib_num(0),
-	m_last_blendmode(0),
+	m_last_blendmode(GPU_BLEND_SOLID),
+	m_last_frontface(true),
 	m_materialCachingInfo(0)
 {
-	m_viewmatrix.Identity();
+	m_viewmatrix.setIdentity();
+	m_viewinvmatrix.setIdentity();
 	
 	for (int i = 0; i < 32; i++)
 	{
@@ -87,81 +92,9 @@ RAS_OpenGLRasterizer::~RAS_OpenGLRasterizer()
 {
 }
 
-
-
-static void Myinit_gl_stuff(void)	
-{
-	float mat_specular[] = { 0.5, 0.5, 0.5, 1.0 };
-	float mat_shininess[] = { 35.0 };
-/*  	float one= 1.0; */
-	int a, x, y;
-	GLubyte pat[32*32];
-	const GLubyte *patc= pat;
-		
-	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_specular);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
-
-
-#if defined(__FreeBSD) || defined(__linux__)
-	glDisable(GL_DITHER);	/* op sgi/sun hardware && 12 bits */
-#endif
-	
-	/* no local viewer, looks ugly in ortho mode */
-	/* glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, &one); */
-	
-	glDepthFunc(GL_LEQUAL);
-	/* scaling matrices */
-	glEnable(GL_NORMALIZE);
-
-	glShadeModel(GL_FLAT);
-
-	glDisable(GL_ALPHA_TEST);
-	glDisable(GL_BLEND);
-	glDisable(GL_DEPTH_TEST);
-	glDisable(GL_FOG);
-	glDisable(GL_LIGHTING);
-	glDisable(GL_LOGIC_OP);
-	glDisable(GL_STENCIL_TEST);
-	glDisable(GL_TEXTURE_1D);
-	glDisable(GL_TEXTURE_2D);
-
-	glEnableClientState(GL_VERTEX_ARRAY);
-	glEnableClientState(GL_NORMAL_ARRAY);
-
-	glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
-	glPixelTransferi(GL_RED_SCALE, 1);
-	glPixelTransferi(GL_RED_BIAS, 0);
-	glPixelTransferi(GL_GREEN_SCALE, 1);
-	glPixelTransferi(GL_GREEN_BIAS, 0);
-	glPixelTransferi(GL_BLUE_SCALE, 1);
-	glPixelTransferi(GL_BLUE_BIAS, 0);
-	glPixelTransferi(GL_ALPHA_SCALE, 1);
-	glPixelTransferi(GL_ALPHA_BIAS, 0);
-
-	a = 0;
-	for(x=0; x<32; x++)
-	{
-		for(y=0; y<4; y++)
-		{
-			if( (x) & 1) pat[a++]= 0x88;
-			else pat[a++]= 0x22;
-		}
-	}
-	
-	glPolygonStipple(patc);
-	
-	glFrontFace(GL_CCW);
-	glCullFace(GL_BACK);
-	glEnable(GL_CULL_FACE);
-}
-
-
-
 bool RAS_OpenGLRasterizer::Init()
 {
-
-	Myinit_gl_stuff();
+	GPU_state_init();
 
 	m_redback = 0.4375;
 	m_greenback = 0.4375;
@@ -172,7 +105,8 @@ bool RAS_OpenGLRasterizer::Init()
 	m_ambg = 0.0f;
 	m_ambb = 0.0f;
 
-	SetBlendingMode(0);
+	SetBlendingMode(GPU_BLEND_SOLID);
+	SetFrontFace(true);
 
 	glClearColor(m_redback,m_greenback,m_blueback,m_alphaback);
 	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
@@ -344,7 +278,8 @@ bool RAS_OpenGLRasterizer::BeginFrame(int drawingmode, double time)
 		glEnable (GL_CULL_FACE);
 	}
 
-	SetBlendingMode(0);
+	SetBlendingMode(GPU_BLEND_SOLID);
+	SetFrontFace(true);
 
 	glShadeModel(GL_SMOOTH);
 
@@ -359,28 +294,16 @@ void RAS_OpenGLRasterizer::SetDrawingMode(int drawingmode)
 {
 	m_drawingmode = drawingmode;
 
-	switch (m_drawingmode)
-	{
-	case KX_WIREFRAME:
-		{
-			glDisable (GL_CULL_FACE);
-			break;
-		}
-	default:
-		{
-		}
-	}
+	if(m_drawingmode == KX_WIREFRAME)
+		glDisable(GL_CULL_FACE);
 }
 
-
-
 int RAS_OpenGLRasterizer::GetDrawingMode()
 {
 	return m_drawingmode;
 }
 
 
-
 void RAS_OpenGLRasterizer::SetDepthMask(DepthMask depthmask)
 {
 	glDepthMask(depthmask == KX_DEPTHMASK_DISABLED ? GL_FALSE : GL_TRUE);
@@ -573,294 +496,84 @@ void RAS_OpenGLRasterizer::SwapBuffers()
 
 
 
-void RAS_OpenGLRasterizer::GetViewMatrix(MT_Matrix4x4 &mat) const
+const MT_Matrix4x4& RAS_OpenGLRasterizer::GetViewMatrix() const
 {
-	float viewmat[16];
-	glGetFloatv(GL_MODELVIEW_MATRIX, viewmat);
-	mat.setValue(viewmat);
+	return m_viewmatrix;
 }
 
-
-
-void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays,
-									const vecIndexArrays & indexarrays,
-									DrawMode mode,
-									bool useObjectColor,
-									const MT_Vector4& rgbacolor,
-									class KX_ListSlot** slot
-									)
-{ 
-	const RAS_TexVert* vertexarray;
-	unsigned int numindices, vt;
-
-	for (vt=0;vt<vertexarrays.size();vt++)
-	{
-		vertexarray = &((*vertexarrays[vt]) [0]);
-		const KX_IndexArray & indexarray = (*indexarrays[vt]);
-		numindices = indexarray.size();
-		
-		if (!numindices)
-			break;
-		
-		int vindex=0;
-		switch (mode)
-		{
-		case KX_MODE_LINES:
-			{
-				glBegin(GL_LINES);
-				vindex=0;
-				for (unsigned int i=0;i<numindices;i+=2)
-				{
-					glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ());
-					glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ());
-				}
-				glEnd();
-			}
-			break;
-		case KX_MODE_QUADS:
-			{
-				glBegin(GL_QUADS);
-				vindex=0;
-				if (useObjectColor)
-				{
-					for (unsigned int i=0;i<numindices;i+=4)
-					{
-
-						glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
-
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-					}
-				}
-				else
-				{
-					for (unsigned int i=0;i<numindices;i+=4)
-					{
-						// This looks curiously endian unsafe to me.
-						// However it depends on the way the colors are packed into 
-						// the m_rgba field of RAS_TexVert
-
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-					}
-				}
-				glEnd();	
-				break;
-			}
-		case KX_MODE_TRIANGLES:
-			{
-				glBegin(GL_TRIANGLES);
-				vindex=0;
-				if (useObjectColor)
-				{
-					for (unsigned int i=0;i<numindices;i+=3)
-					{
-
-						glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
-
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-					}
-				}
-				else 
-				{
-					for (unsigned int i=0;i<numindices;i+=3)
-					{
-
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-						
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						glTexCoord2fv(vertexarray[(indexarray[vindex])].getUV1());
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-					}
-				}
-				glEnd();	
-				break;
-			}
-		default:
-			{
-			}
-			
-		} // switch
-	} // for each vertexarray
-
+const MT_Matrix4x4& RAS_OpenGLRasterizer::GetViewInvMatrix() const
+{
+	return m_viewinvmatrix;
 }
 
-void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexarrays,
-									const vecIndexArrays & indexarrays,
-									DrawMode mode,
+void RAS_OpenGLRasterizer::IndexPrimitives_3DText(RAS_MeshSlot& ms,
 									class RAS_IPolyMaterial* polymat,
-									class RAS_IRenderTools* rendertools,
-									bool useObjectColor,
-									const MT_Vector4& rgbacolor
-									)
+									class RAS_IRenderTools* rendertools)
 { 
-	const RAS_TexVert* vertexarray;
-	unsigned int numindices, vt;
-	
-	if (useObjectColor)
-	{
+	bool obcolor = ms.m_bObjectColor;
+	MT_Vector4& rgba = ms.m_RGBAcolor;
+	RAS_MeshSlot::iterator it;
+
+	// handle object color
+	if (obcolor) {
 		glDisableClientState(GL_COLOR_ARRAY);
-		glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
+		glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
 	}
 	else
-	{
 		glEnableClientState(GL_COLOR_ARRAY);
-	}
-	
-	for (vt=0;vt<vertexarrays.size();vt++)
-	{
-		vertexarray = &((*vertexarrays[vt]) [0]);
-		const KX_IndexArray & indexarray = (*indexarrays[vt]);
-		numindices = indexarray.size();
-		
-		if (!numindices)
-			break;
+
+	for(ms.begin(it); !ms.end(it); ms.next(it)) {
+		RAS_TexVert *vertex;
+		size_t i, j, numvert;
 		
-		int vindex=0;
-		switch (mode)
-		{
-		case KX_MODE_LINES:
-			{
-				glBegin(GL_LINES);
-				vindex=0;
-				for (unsigned int i=0;i<numindices;i+=2)
-				{
-					glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ());
-					glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ());
-				}
-				glEnd();
-			}
-			break;
-		case KX_MODE_QUADS:
+		numvert = it.array->m_type;
+
+		if(it.array->m_type == RAS_DisplayArray::LINE) {
+			// line drawing, no text
+			glBegin(GL_LINES);
+
+			for(i=0; i<it.totindex; i+=2)
 			{
-				vindex=0;
-				for (unsigned int i=0;i<numindices;i+=4)
-				{
-					float v1[3],v2[3],v3[3],v4[3];
-					
-					v1[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
-					v1[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
-					v1[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
-					vindex++;
-					
-					v2[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
-					v2[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
-					v2[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
-					vindex++;
-					
-					v3[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
-					v3[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
-					v3[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
-					vindex++;
-					
-					v4[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
-					v4[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
-					v4[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
-					
-					vindex++;
-					
-					rendertools->RenderText(polymat->GetDrawingMode(),polymat,v1,v2,v3,v4);
-					ClearCachingInfo();
-				}
-				break;
+				vertex = &it.vertex[it.index[i]];
+				glVertex3fv(vertex->getXYZ());
+
+				vertex = &it.vertex[it.index[i+1]];
+				glVertex3fv(vertex->getXYZ());
 			}
-		case KX_MODE_TRIANGLES:
+
+			glEnd();
+		}
+		else {
+			// triangle and quad text drawing
+			for(i=0; i<it.totindex; i+=numvert)
 			{
-				glBegin(GL_TRIANGLES);
-				vindex=0;
-				for (unsigned int i=0;i<numindices;i+=3)
-				{
-					float v1[3],v2[3],v3[3];
-					
-					v1[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
-					v1[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
-					v1[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
-					vindex++;
-					
-					v2[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
-					v2[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
-					v2[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
-					vindex++;
-					
-					v3[0] = vertexarray[(indexarray[vindex])].getLocalXYZ()[0];
-					v3[1] = vertexarray[(indexarray[vindex])].getLocalXYZ()[1];
-					v3[2] = vertexarray[(indexarray[vindex])].getLocalXYZ()[2];
-					vindex++;
-					
-					rendertools->RenderText(polymat->GetDrawingMode(),polymat,v1,v2,v3,NULL);		
-					ClearCachingInfo();
+				float v[4][3];
+				int glattrib, unit;
+
+				for(j=0; j<numvert; j++) {
+					vertex = &it.vertex[it.index[i+j]];
+
+					v[j][0] = vertex->getXYZ()[0];
+					v[j][1] = vertex->getXYZ()[1];
+					v[j][2] = vertex->getXYZ()[2];
 				}
-				glEnd();	
-				break;
-			}
-		default:
-			{
+
+				// find the right opengl attribute
+				glattrib = -1;
+				if(GLEW_ARB_vertex_program)
+					for(unit=0; unit<m_attrib_num; unit++)
+						if(m_attrib[unit] == RAS_TEXCO_UV1)
+							glattrib = unit;
+				
+				rendertools->RenderText(polymat->GetDrawingMode(), polymat,
+					v[0], v[1], v[2], (numvert == 4)? v[3]: NULL, glattrib);
+
+				ClearCachingInfo();
 			}
-		}	//switch
-	}	//for each vertexarray
+		}
+	}
+
+	glDisableClientState(GL_COLOR_ARRAY);
 }
 
 void RAS_OpenGLRasterizer::SetTexCoordNum(int num)
@@ -897,14 +610,14 @@ void RAS_OpenGLRasterizer::TexCoord(const RAS_TexVert &tv)
 
 	if(GLEW_ARB_multitexture) {
 		for(unit=0; unit<m_texco_num; unit++) {
-			if(tv.getFlag() & TV_2NDUV && (int)tv.getUnit() == unit) {
+			if(tv.getFlag() & RAS_TexVert::SECOND_UV && (int)tv.getUnit() == unit) {
 				glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, tv.getUV2());
 				continue;
 			}
 			switch(m_texco[unit]) {
 			case RAS_TEXCO_ORCO:
 			case RAS_TEXCO_GLOB:
-				glMultiTexCoord3fvARB(GL_TEXTURE0_ARB+unit, tv.getLocalXYZ());
+				glMultiTexCoord3fvARB(GL_TEXTURE0_ARB+unit, tv.getXYZ());
 				break;
 			case RAS_TEXCO_UV1:
 				glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, tv.getUV1());
@@ -929,7 +642,7 @@ void RAS_OpenGLRasterizer::TexCoord(const RAS_TexVert &tv)
 			switch(m_attrib[unit]) {
 			case RAS_TEXCO_ORCO:
 			case RAS_TEXCO_GLOB:
-				glVertexAttrib3fvARB(unit, tv.getLocalXYZ());
+				glVertexAttrib3fvARB(unit, tv.getXYZ());
 				break;
 			case RAS_TEXCO_UV1:
 				glVertexAttrib2fvARB(unit, tv.getUV1());
@@ -953,211 +666,80 @@ void RAS_OpenGLRasterizer::TexCoord(const RAS_TexVert &tv)
 	}
 
 }
-void RAS_OpenGLRasterizer::Tangent(	const RAS_TexVert& v1,
-									const RAS_TexVert& v2,
-									const RAS_TexVert& v3,
-									const MT_Vector3 &no)
+
+void RAS_OpenGLRasterizer::IndexPrimitives(RAS_MeshSlot& ms)
 {
-	// TODO: set for deformer... 
-	MT_Vector3 x1(v1.getLocalXYZ()), x2(v2.getLocalXYZ()), x3(v3.getLocalXYZ());
-	MT_Vector2 uv1(v1.getUV1()), uv2(v2.getUV1()), uv3(v3.getUV1());
-	MT_Vector3 dx1(x2 - x1), dx2(x3 - x1);
-	MT_Vector2 duv1(uv2 - uv1), duv2(uv3 - uv1);
-
-	MT_Scalar r = 1.0 / (duv1.x() * duv2.y() - duv2.x() * duv1.y());
-	duv1 *= r;
-	duv2 *= r;
-	MT_Vector3 sdir(duv2.y() * dx1 - duv1.y() * dx2);
-	MT_Vector3 tdir(duv1.x() * dx2 - duv2.x() * dx1);
-
-	// Gram-Schmidt orthogonalize
-	MT_Vector3 t(sdir - no.cross(no.cross(sdir)));
-	if (!MT_fuzzyZero(t)) t /= t.length();
-
-	float tangent[4];
-	t.getValue(tangent);
-	// Calculate handedness
-	tangent[3] = no.dot(sdir.cross(tdir)) < 0.0 ? -1.0 : 1.0;
+	IndexPrimitivesInternal(ms, false);
 }
 
+void RAS_OpenGLRasterizer::IndexPrimitivesMulti(RAS_MeshSlot& ms)
+{
+	IndexPrimitivesInternal(ms, true);
+}
 
-void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
-		const vecVertexArray& vertexarrays,
-		const vecIndexArrays & indexarrays,
-		DrawMode mode,
-		bool useObjectColor,
-		const MT_Vector4& rgbacolor,
-		class KX_ListSlot** slot
-		)
+void RAS_OpenGLRasterizer::IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi)
 { 
+	bool obcolor = ms.m_bObjectColor;
+	bool wireframe = m_drawingmode <= KX_WIREFRAME;
+	MT_Vector4& rgba = ms.m_RGBAcolor;
+	RAS_MeshSlot::iterator it;
+
+	// iterate over display arrays, each containing an index + vertex array
+	for(ms.begin(it); !ms.end(it); ms.next(it)) {
+		RAS_TexVert *vertex;
+		size_t i, j, numvert;
+		
+		numvert = it.array->m_type;
 
-	const RAS_TexVert* vertexarray;
-	unsigned int numindices,vt;
-
-	for (vt=0;vt<vertexarrays.size();vt++)
-	{
-		vertexarray = &((*vertexarrays[vt]) [0]);
-		const KX_IndexArray & indexarray = (*indexarrays[vt]);
-		numindices = indexarray.size();
-
-		if (!numindices)
-			break;
+		if(it.array->m_type == RAS_DisplayArray::LINE) {
+			// line drawing
+			glBegin(GL_LINES);
 
-		int vindex=0;
-		switch (mode)
-		{
-		case KX_MODE_LINES:
+			for(i=0; i<it.totindex; i+=2)
 			{
-				glBegin(GL_LINES);
-				vindex=0;
-				for (unsigned int i=0;i<numindices;i+=2)
-				{
-					glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ());
-					glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ());
-				}
-				glEnd();
+				vertex = &it.vertex[it.index[i]];
+				glVertex3fv(vertex->getXYZ());
+
+				vertex = &it.vertex[it.index[i+1]];
+				glVertex3fv(vertex->getXYZ());
 			}
-			break;
-		case KX_MODE_QUADS:
-			{
+
+			glEnd();
+		}
+		else {
+			// triangle and quad drawing
+			if(it.array->m_type == RAS_DisplayArray::TRIANGLE)
+				glBegin(GL_TRIANGLES);
+			else
 				glBegin(GL_QUADS);
-				vindex=0;
-				if (useObjectColor)
-				{
-					for (unsigned int i=0;i<numindices;i+=4)
-					{
-
-						glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
-
-						//
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-
-						//
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-
-						//
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-
-						//
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-					}
-				}
-				else
-				{
-					for (unsigned int i=0;i<numindices;i+=4)
-					{
-						// This looks curiously endian unsafe to me.
-						// However it depends on the way the colors are packed into 
-						// the m_rgba field of RAS_TexVert
-				
-						//
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-				
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-					
-						//
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-
-						//
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-
-						//
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-					}
-				}
-				glEnd();	
-				break;
-			}
-		case KX_MODE_TRIANGLES:
+
+			for(i=0; i<it.totindex; i+=numvert)
 			{
-				glBegin(GL_TRIANGLES);
-				vindex=0;
-				if (useObjectColor)
-				{
-					for (unsigned int i=0;i<numindices;i+=3)
-					{
-
-						glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
-						//
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-
-						//
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-
-						//
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-					}
-				}
-				else 
-				{
-					for (unsigned int i=0;i<numindices;i+=3)
-					{
-						//
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-				
-						//
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
-
-						//
-						glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA()));
-						glNormal3fv(vertexarray[(indexarray[vindex])].getNormal());
-						TexCoord(vertexarray[(indexarray[vindex])]);
-						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
-						vindex++;
+				if(obcolor)
+					glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
+
+				for(j=0; j<numvert; j++) {
+					vertex = &it.vertex[it.index[i+j]];
+
+					if(!wireframe) {
+						if(!obcolor)
+							glColor4ubv((const GLubyte *)(vertex->getRGBA()));
+
+						glNormal3fv(vertex->getNormal());
+
+						if(multi)
+							TexCoord(*vertex);
+						else
+							glTexCoord2fv(vertex->getUV1());
 					}
+
+					glVertex3fv(vertex->getXYZ());
 				}
-				glEnd();	
-				break;
-			}
-		default:
-			{
 			}
-		} // switch
-	} // for each vertexarray
+
+			glEnd();
+		}
+	}
 }
 
 void RAS_OpenGLRasterizer::SetProjectionMatrix(MT_CmMatrix4x4 &mat)
@@ -1232,7 +814,7 @@ MT_Matrix4x4 RAS_OpenGLRasterizer::GetFrustumMatrix(
 void RAS_OpenGLRasterizer::SetViewMatrix(const MT_Matrix4x4 &mat, const MT_Vector3& campos,
 		const MT_Point3 &, const MT_Quaternion &camOrientQuat)
 {
-	MT_Matrix4x4 viewMat = mat;
+	m_viewmatrix = mat;
 
 	// correction for stereo
 	if(m_stereomode != RAS_STEREO_NOSTEREO)
@@ -1259,7 +841,7 @@ void RAS_OpenGLRasterizer::SetViewMatrix(const MT_Matrix4x4 &mat, const MT_Vecto
 				MT_Transform transform;
 				transform.setIdentity();
 				transform.translate(-(eyeline * m_eyeseparation / 2.0));
-				viewMat *= transform;
+				m_viewmatrix *= transform;
 				}
 				break;
 			case RAS_STEREO_RIGHTEYE:
@@ -1268,20 +850,21 @@ void RAS_OpenGLRasterizer::SetViewMatrix(const MT_Matrix4x4 &mat, const MT_Vecto
 				MT_Transform transform;
 				transform.setIdentity();
 				transform.translate(eyeline * m_eyeseparation / 2.0);
-				viewMat *= transform;
+				m_viewmatrix *= transform;
 				}
 				break;
 		}
 	}
 
-	// convert row major matrix 'viewMat' to column major for OpenGL
-	MT_Scalar cammat[16];
-	viewMat.getValue(cammat);
-	MT_CmMatrix4x4 viewCmmat = cammat;
+	m_viewinvmatrix = m_viewmatrix;
+	m_viewinvmatrix.invert();
+
+	// note: getValue gives back column major as needed by OpenGL
+	MT_Scalar glviewmat[16];
+	m_viewmatrix.getValue(glviewmat);
 
 	glMatrixMode(GL_MODELVIEW);
-	m_viewmatrix = viewCmmat;
-	glLoadMatrixd(&m_viewmatrix(0,0));
+	glLoadMatrixd(glviewmat);
 	m_campos = campos;
 }
 
@@ -1292,20 +875,6 @@ const MT_Point3& RAS_OpenGLRasterizer::GetCameraPosition()
 }
 
 
-
-void RAS_OpenGLRasterizer::LoadViewMatrix()
-{
-	glLoadMatrixd(&m_viewmatrix(0,0));
-}
-
-
-
-void RAS_OpenGLRasterizer::EnableTextures(bool enable)
-{
-}
-
-
-
 void RAS_OpenGLRasterizer::SetCullFace(bool enable)
 {
 	if (enable)
@@ -1388,23 +957,23 @@ void RAS_OpenGLRasterizer::SetBlendingMode(int blendmode)
 	if(blendmode == m_last_blendmode)
 		return;
 
-	if(blendmode == 0) {
+	if(blendmode == GPU_BLEND_SOLID) {
 		glDisable(GL_BLEND);
 		glDisable(GL_ALPHA_TEST);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	}
-	else if(blendmode == 1) {
+	else if(blendmode == GPU_BLEND_ADD) {
 		glBlendFunc(GL_ONE, GL_ONE);
 		glEnable(GL_BLEND);
 		glDisable(GL_ALPHA_TEST);
 	}
-	else if(blendmode == 2) {
+	else if(blendmode == GPU_BLEND_ALPHA) {
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 		glEnable(GL_BLEND);
 		glEnable(GL_ALPHA_TEST);
 		glAlphaFunc(GL_GREATER, 0.0f);
 	}
-	else if(blendmode == 4) {
+	else if(blendmode == GPU_BLEND_CLIP) {
 		glDisable(GL_BLEND); 
 		glEnable(GL_ALPHA_TEST);
 		glAlphaFunc(GL_GREATER, 0.5f);
@@ -1413,3 +982,16 @@ void RAS_OpenGLRasterizer::SetBlendingMode(int blendmode)
 	m_last_blendmode = blendmode;
 }
 
+void RAS_OpenGLRasterizer::SetFrontFace(bool ccw)
+{
+	if(m_last_frontface == ccw)
+		return;
+
+	if(ccw)
+		glFrontFace(GL_CCW);
+	else
+		glFrontFace(GL_CW);
+	
+	m_last_frontface = ccw;
+}
+
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
index 02056cce446..368bd4312ac 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
@@ -41,7 +41,7 @@ using namespace std;
 #include "RAS_MaterialBucket.h"
 #include "RAS_ICanvas.h"
 
-#define RAS_MAX_TEXCO	3	// match in BL_Material
+#define RAS_MAX_TEXCO	8	// match in BL_Material
 #define RAS_MAX_ATTRIB	16	// match in BL_BlenderShader
 
 struct	OglDebugLine
@@ -77,7 +77,8 @@ class RAS_OpenGLRasterizer : public RAS_IRasterizer
 	float			m_ambb;
 
 	double			m_time;
-	MT_CmMatrix4x4	m_viewmatrix;
+	MT_Matrix4x4	m_viewmatrix;
+	MT_Matrix4x4	m_viewinvmatrix;
 	MT_Point3		m_campos;
 
 	StereoMode		m_stereomode;
@@ -100,6 +101,7 @@ protected:
 	int				m_texco_num;
 	int				m_attrib_num;
 	int				m_last_blendmode;
+	bool			m_last_frontface;
 
 	/** Stores the caching information for the last material activated. */
 	RAS_IPolyMaterial::TCachingInfo m_materialCachingInfo;
@@ -144,33 +146,15 @@ public:
 	virtual float	GetFocalLength();
 
 	virtual void	SwapBuffers();
-	virtual void	IndexPrimitives(
-						const vecVertexArray& vertexarrays,
-						const vecIndexArrays & indexarrays,
-						DrawMode mode,
-						bool useObjectColor,
-						const MT_Vector4& rgbacolor,
-						class KX_ListSlot** slot
-					);
 
+	virtual void	IndexPrimitives(class RAS_MeshSlot& ms);
+	virtual void	IndexPrimitivesMulti(class RAS_MeshSlot& ms);
 	virtual void	IndexPrimitives_3DText(
-						const vecVertexArray& vertexarrays,
-						const vecIndexArrays & indexarrays,
-						DrawMode mode,
+						class RAS_MeshSlot& ms,
 						class RAS_IPolyMaterial* polymat,
-						class RAS_IRenderTools* rendertools,
-						bool useObjectColor,
-						const MT_Vector4& rgbacolor
-					);
-
-	virtual void IndexPrimitivesMulti( 
-						const vecVertexArray& vertexarrays,
-						const vecIndexArrays & indexarrays,
-						DrawMode mode,
-						bool useObjectColor,
-						const MT_Vector4& rgbacolor,
-						class KX_ListSlot** slot);
+						class RAS_IRenderTools* rendertools);
 
+	void			IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi);
 
 	virtual void	SetProjectionMatrix(MT_CmMatrix4x4 & mat);
 	virtual void	SetProjectionMatrix(const MT_Matrix4x4 & mat);
@@ -182,7 +166,6 @@ public:
 					);
 
 	virtual const	MT_Point3& GetCameraPosition();
-	virtual void	LoadViewMatrix();
 	
 	virtual void	SetFog(
 						float start,
@@ -214,7 +197,6 @@ public:
 	virtual void	SetDrawingMode(int drawingmode);
 	virtual int		GetDrawingMode();
 
-	virtual void	EnableTextures(bool enable);
 	virtual void	SetCullFace(bool enable);
 	virtual void	SetLines(bool enable);
 
@@ -270,13 +252,10 @@ public:
 	virtual void SetTexCoord(TexCoGen coords, int unit);
 	virtual void SetAttrib(TexCoGen coords, int unit);
 
-	void			TexCoord(const RAS_TexVert &tv);
-	virtual void	GetViewMatrix(MT_Matrix4x4 &mat) const;
+	void TexCoord(const RAS_TexVert &tv);
 
-	void	Tangent(const RAS_TexVert& v1,
-					const RAS_TexVert& v2,
-					const RAS_TexVert& v3,
-					const MT_Vector3 &no);
+	const MT_Matrix4x4&	GetViewMatrix() const;
+	const MT_Matrix4x4&	GetViewInvMatrix() const;
 	
 	virtual void	EnableMotionBlur(float motionblurvalue);
 	virtual void	DisableMotionBlur();
@@ -293,6 +272,7 @@ public:
 	};
 
 	virtual void	SetBlendingMode(int blendmode);
+	virtual void	SetFrontFace(bool ccw);
 };
 
 #endif //__RAS_OPENGLRASTERIZER
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp
index c78a97ad7be..2cb3b52adfb 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp
@@ -33,6 +33,7 @@
 #include <stdlib.h>
 
 #include "GL/glew.h"
+#include "GPU_extensions.h"
 
 #include "STR_String.h"
 #include "RAS_TexVert.h"
@@ -77,16 +78,16 @@ void RAS_VAOpenGLRasterizer::SetDrawingMode(int drawingmode)
 	{
 		case KX_BOUNDINGBOX:
 		case KX_WIREFRAME:
-			glDisableClientState(GL_COLOR_ARRAY);
-			glDisable(GL_CULL_FACE);
+			//glDisableClientState(GL_COLOR_ARRAY);
+			//glDisable(GL_CULL_FACE);
 			break;
 		case KX_SOLID:
-			glDisableClientState(GL_COLOR_ARRAY);
+			//glDisableClientState(GL_COLOR_ARRAY);
 			break;
 		case KX_TEXTURED:
 		case KX_SHADED:
 		case KX_SHADOW:
-			glEnableClientState(GL_COLOR_ARRAY);
+			//glEnableClientState(GL_COLOR_ARRAY);
 		default:
 			break;
 	}
@@ -98,141 +99,121 @@ void RAS_VAOpenGLRasterizer::Exit()
 	glEnableClientState(GL_NORMAL_ARRAY);
 	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 	glDisableClientState(GL_COLOR_ARRAY);
-	EnableTextures(false);
 
 	RAS_OpenGLRasterizer::Exit();
 }
 
-void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays,
-							const vecIndexArrays & indexarrays,
-							DrawMode mode,
-							bool useObjectColor,
-							const MT_Vector4& rgbacolor,
-							class KX_ListSlot** slot)
+void RAS_VAOpenGLRasterizer::IndexPrimitives(RAS_MeshSlot& ms)
 {
-	static const GLsizei vtxstride = sizeof(RAS_TexVert);
+	static const GLsizei stride = sizeof(RAS_TexVert);
+	bool wireframe = m_drawingmode <= KX_WIREFRAME;
+	RAS_MeshSlot::iterator it;
 	GLenum drawmode;
-	if(mode == KX_MODE_TRIANGLES)
-		drawmode = GL_TRIANGLES;
-	else if(mode == KX_MODE_QUADS)
-		drawmode = GL_QUADS;
-	else
-		drawmode = GL_LINES;
 
-	const RAS_TexVert* vertexarray;
-	unsigned int numindices, vt;
-
-	if (drawmode != GL_LINES)
-	{
-		if (useObjectColor)
-		{
-			glDisableClientState(GL_COLOR_ARRAY);
-			glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
-		} else
-		{
-			glColor4d(0,0,0,1.0);
-			glEnableClientState(GL_COLOR_ARRAY);
-		}
-	}
-	else
-	{
-		glColor3d(0,0,0);
-	}
-
-	EnableTextures(false);
-	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	if(!wireframe)
+		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
 	// use glDrawElements to draw each vertexarray
-	for (vt=0;vt<vertexarrays.size();vt++)
-	{
-		vertexarray = &((*vertexarrays[vt]) [0]);
-		const KX_IndexArray & indexarray = (*indexarrays[vt]);
-		numindices = indexarray.size();
-
-		if (!numindices)
+	for(ms.begin(it); !ms.end(it); ms.next(it)) {
+		if(it.totindex == 0)
 			continue;
-		
-		glVertexPointer(3,GL_FLOAT,vtxstride,vertexarray->getLocalXYZ());
-		glNormalPointer(GL_FLOAT,vtxstride,vertexarray->getNormal());
-		glTexCoordPointer(2,GL_FLOAT,vtxstride,vertexarray->getUV1());
-		if(glIsEnabled(GL_COLOR_ARRAY))
-			glColorPointer(4,GL_UNSIGNED_BYTE,vtxstride,vertexarray->getRGBA());
 
-		//if(m_Lock)
-		//	local->Begin(vertexarrays[vt]->size());
+		// drawing mode
+		if(it.array->m_type == RAS_DisplayArray::TRIANGLE)
+			drawmode = GL_TRIANGLES;
+		else if(it.array->m_type == RAS_DisplayArray::QUAD)
+			drawmode = GL_QUADS;
+		else
+			drawmode = GL_LINES;
+
+		// colors
+		if (drawmode != GL_LINES && !wireframe) {
+			if (ms.m_bObjectColor) {
+				const MT_Vector4& rgba = ms.m_RGBAcolor;
 
-		// here the actual drawing takes places
-		glDrawElements(drawmode,numindices,GL_UNSIGNED_SHORT,&(indexarray[0]));
+				glDisableClientState(GL_COLOR_ARRAY);
+				glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
+			}
+			else {
+				glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
+				glEnableClientState(GL_COLOR_ARRAY);
+			}
+		}
+		else
+			glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
+
+		glVertexPointer(3, GL_FLOAT, stride, it.vertex->getXYZ());
+		glNormalPointer(GL_FLOAT, stride, it.vertex->getNormal());
+		if(!wireframe) {
+			glTexCoordPointer(2, GL_FLOAT, stride, it.vertex->getUV1());
+			if(glIsEnabled(GL_COLOR_ARRAY))
+				glColorPointer(4, GL_UNSIGNED_BYTE, stride, it.vertex->getRGBA());
+		}
 
-		//if(m_Lock)
-		//	local->End();
+		// here the actual drawing takes places
+		glDrawElements(drawmode, it.totindex, GL_UNSIGNED_SHORT, it.index);
 	}
 
-	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	if(!wireframe) {
+		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+		glDisableClientState(GL_COLOR_ARRAY);
+	}
 }
 
-void RAS_VAOpenGLRasterizer::IndexPrimitivesMulti( const vecVertexArray& vertexarrays,
-							const vecIndexArrays & indexarrays,
-							DrawMode mode,
-							bool useObjectColor,
-							const MT_Vector4& rgbacolor,
-							class KX_ListSlot** slot)
+void RAS_VAOpenGLRasterizer::IndexPrimitivesMulti(RAS_MeshSlot& ms)
 {
-	static const GLsizei vtxstride = sizeof(RAS_TexVert);
-
+	static const GLsizei stride = sizeof(RAS_TexVert);
+	bool wireframe = m_drawingmode <= KX_WIREFRAME;
+	RAS_MeshSlot::iterator it;
 	GLenum drawmode;
-	if(mode == KX_MODE_TRIANGLES)
-		drawmode = GL_TRIANGLES;
-	else if(mode == KX_MODE_QUADS)
-		drawmode = GL_QUADS;
-	else
-		drawmode = GL_LINES;
 
-	const RAS_TexVert* vertexarray;
-	unsigned int numindices, vt;
-
-	if (drawmode != GL_LINES)
-	{
-		if (useObjectColor)
-		{
-			glDisableClientState(GL_COLOR_ARRAY);
-			glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
-		}
-		else
-		{
-			glColor4d(0,0,0,1.0);
-			glEnableClientState(GL_COLOR_ARRAY);
-		}
-	}
-	else
-	{
-		glColor3d(0,0,0);
-	}
+	if(!wireframe)
+		EnableTextures(true);
 
 	// use glDrawElements to draw each vertexarray
-	for (vt=0;vt<vertexarrays.size();vt++)
-	{
-		vertexarray = &((*vertexarrays[vt]) [0]);
-		const KX_IndexArray & indexarray = (*indexarrays[vt]);
-		numindices = indexarray.size();
-
-		if (!numindices)
+	for(ms.begin(it); !ms.end(it); ms.next(it)) {
+		if(it.totindex == 0)
 			continue;
 
-		glVertexPointer(3,GL_FLOAT,vtxstride,vertexarray->getLocalXYZ());
-		glNormalPointer(GL_FLOAT,vtxstride,vertexarray->getNormal());
-		TexCoordPtr(vertexarray);
-		if(glIsEnabled(GL_COLOR_ARRAY))
-			glColorPointer(4,GL_UNSIGNED_BYTE,vtxstride,vertexarray->getRGBA());
+		// drawing mode
+		if(it.array->m_type == RAS_DisplayArray::TRIANGLE)
+			drawmode = GL_TRIANGLES;
+		else if(it.array->m_type == RAS_DisplayArray::QUAD)
+			drawmode = GL_QUADS;
+		else
+			drawmode = GL_LINES;
+
+		// colors
+		if (drawmode != GL_LINES && !wireframe) {
+			if (ms.m_bObjectColor) {
+				const MT_Vector4& rgba = ms.m_RGBAcolor;
 
-		//if(m_Lock)
-		//	local->Begin(vertexarrays[vt]->size());
+				glDisableClientState(GL_COLOR_ARRAY);
+				glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
+			}
+			else {
+				glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
+				glEnableClientState(GL_COLOR_ARRAY);
+			}
+		}
+		else
+			glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
+
+		glVertexPointer(3, GL_FLOAT, stride, it.vertex->getXYZ());
+		glNormalPointer(GL_FLOAT, stride, it.vertex->getNormal());
+		if(!wireframe) {
+			TexCoordPtr(it.vertex);
+			if(glIsEnabled(GL_COLOR_ARRAY))
+				glColorPointer(4, GL_UNSIGNED_BYTE, stride, it.vertex->getRGBA());
+		}
 
 		// here the actual drawing takes places
-		glDrawElements(drawmode,numindices,GL_UNSIGNED_SHORT,&(indexarray[0]));
-		
-		//if(m_Lock)
-		//	local->End();
+		glDrawElements(drawmode, it.totindex, GL_UNSIGNED_SHORT, it.index);
+	}
+
+	if(!wireframe) {
+		glDisableClientState(GL_COLOR_ARRAY);
+		EnableTextures(false);
 	}
 }
 
@@ -248,7 +229,7 @@ void RAS_VAOpenGLRasterizer::TexCoordPtr(const RAS_TexVert *tv)
 		for(unit=0; unit<m_texco_num; unit++)
 		{
 			glClientActiveTextureARB(GL_TEXTURE0_ARB+unit);
-			if(tv->getFlag() & TV_2NDUV && (int)tv->getUnit() == unit) {
+			if(tv->getFlag() & RAS_TexVert::SECOND_UV && (int)tv->getUnit() == unit) {
 				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 				glTexCoordPointer(2, GL_FLOAT, sizeof(RAS_TexVert), tv->getUV2());
 				continue;
@@ -257,7 +238,7 @@ void RAS_VAOpenGLRasterizer::TexCoordPtr(const RAS_TexVert *tv)
 			{
 			case RAS_TEXCO_ORCO:
 			case RAS_TEXCO_GLOB:
-				glTexCoordPointer(3, GL_FLOAT, sizeof(RAS_TexVert),tv->getLocalXYZ());
+				glTexCoordPointer(3, GL_FLOAT, sizeof(RAS_TexVert),tv->getXYZ());
 				break;
 			case RAS_TEXCO_UV1:
 				glTexCoordPointer(2, GL_FLOAT, sizeof(RAS_TexVert),tv->getUV1());
@@ -284,7 +265,7 @@ void RAS_VAOpenGLRasterizer::TexCoordPtr(const RAS_TexVert *tv)
 			switch(m_attrib[unit]) {
 			case RAS_TEXCO_ORCO:
 			case RAS_TEXCO_GLOB:
-				glVertexAttribPointerARB(unit, 3, GL_FLOAT, GL_FALSE, sizeof(RAS_TexVert), tv->getLocalXYZ());
+				glVertexAttribPointerARB(unit, 3, GL_FLOAT, GL_FALSE, sizeof(RAS_TexVert), tv->getXYZ());
 				break;
 			case RAS_TEXCO_UV1:
 				glVertexAttribPointerARB(unit, 2, GL_FLOAT, GL_FALSE, sizeof(RAS_TexVert), tv->getUV1());
@@ -313,11 +294,6 @@ void RAS_VAOpenGLRasterizer::EnableTextures(bool enable)
 	TexCoGen *texco, *attrib;
 	int unit, texco_num, attrib_num;
 
-	/* disable previously enabled texture coordinates and attributes. ideally
-	 * this shouldn't be necessary .. */
-	if(enable)
-		EnableTextures(false);
-
 	/* we cache last texcoords and attribs to ensure we disable the ones that
 	 * were actually last set */
 	if(enable) {
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.h
index e4cc4ace0e8..766bbfbed0e 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.h
@@ -50,22 +50,10 @@ public:
 
 	virtual void	SetDrawingMode(int drawingmode);
 
-	virtual void	IndexPrimitives( const vecVertexArray& vertexarrays,
-		const vecIndexArrays & indexarrays,
-		DrawMode mode,
-		bool useObjectColor,
-		const MT_Vector4& rgbacolor,
-		class KX_ListSlot** slot);
-
-	virtual void IndexPrimitivesMulti( 
-		const vecVertexArray& vertexarrays,
-		const vecIndexArrays & indexarrays,
-		DrawMode mode,
-		bool useObjectColor,
-		const MT_Vector4& rgbacolor,
-		class KX_ListSlot** slot);
-
+	virtual void	IndexPrimitives(class RAS_MeshSlot& ms);
+	virtual void	IndexPrimitivesMulti(class RAS_MeshSlot& ms);
 
+private:
 	virtual void	EnableTextures(bool enable);
 	//virtual bool	QueryArrays(){return true;}
 	//virtual bool	QueryLists(){return m_Lock;}
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript
index 0cf9c326370..8d46528f7f0 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript
@@ -1,12 +1,9 @@
 #!/usr/bin/python
 Import ('env')
 
-if env['WITH_BF_GLEXT'] == 1:
-        env['CPPFLAGS'].append('-DWITH_GLEXT')
-
 sources = env.Glob('*.cpp')
 
 incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/Rasterizer #source/gameengine/BlenderRoutines '
-incs += ' #extern/glew/include ' + env['BF_OPENGL_INC']
+incs += ' #source/blender/gpu #extern/glew/include ' + env['BF_OPENGL_INC']
 
 env.BlenderLib ( 'bf_oglrasterizer', Split(sources), Split(incs), [], libtype=['game','player'], priority=[40, 120] )
diff --git a/source/gameengine/Rasterizer/RAS_Polygon.cpp b/source/gameengine/Rasterizer/RAS_Polygon.cpp
index b74cb9cfcac..50331d7a664 100644
--- a/source/gameengine/Rasterizer/RAS_Polygon.cpp
+++ b/source/gameengine/Rasterizer/RAS_Polygon.cpp
@@ -26,99 +26,82 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #ifdef WIN32
-
 #pragma warning (disable:4786)
 #endif
 
 #include "RAS_Polygon.h"
 
-RAS_Polygon::RAS_Polygon(RAS_MaterialBucket* bucket,
-				bool visible,
-				int numverts,
-				int vtxarrayindex) 
-		:m_bucket(bucket),
-		m_vertexindexbase(numverts),
-		m_numverts(numverts),
-		m_edgecode(65535)
+RAS_Polygon::RAS_Polygon(RAS_MaterialBucket* bucket, RAS_DisplayArray *darray, int numvert)
 {
-	m_vertexindexbase.m_vtxarray = vtxarrayindex ;//m_bucket->FindVertexArray(numverts);
-	m_polyFlags.Visible = visible;
-}
-
+	m_bucket = bucket;
+	m_darray = darray;
+	m_offset[0]= m_offset[1]= m_offset[2]= m_offset[3]= 0;
+	m_numvert = numvert;
 
+	m_edgecode = 255;
+	m_polyflags = 0;
+}
 
 int RAS_Polygon::VertexCount()
 {
-	return m_numverts;
+	return m_numvert;
 }
 
-
-
-void RAS_Polygon::SetVertex(int i,
-						unsigned int vertexindex ) //const MT_Point3& xyz,const MT_Point2& uv,const unsigned int rgbacolor,const MT_Vector3& normal)
+void RAS_Polygon::SetVertexOffset(int i, unsigned short offset)
 {
-	m_vertexindexbase.SetIndex(i,vertexindex); //m_bucket->FindOrAddVertex(m_vertexindexbase.m_vtxarray,
-	//xyz,uv,rgbacolor,normal));
+	m_offset[i] = offset;
 }
 
-
-
-const KX_VertexIndex& RAS_Polygon::GetIndexBase()
+RAS_TexVert *RAS_Polygon::GetVertex(int i)
 {
-	return m_vertexindexbase;
+	return &m_darray->m_vertex[m_offset[i]];
 }
 
-
-
-void RAS_Polygon::SetVisibleWireframeEdges(int edgecode)
+int RAS_Polygon::GetVertexOffset(int i)
 {
-	m_edgecode = edgecode;
+	return m_offset[i];
 }
 
-
-
-// each bit is for a visible edge, starting with bit 1 for the first edge, bit 2 for second etc.
 int RAS_Polygon::GetEdgeCode()
 {
 	return m_edgecode;
 }
 
+void RAS_Polygon::SetEdgeCode(int edgecode)
+{
+	m_edgecode = edgecode;
+}
 
 	
 bool RAS_Polygon::IsVisible()
 {
-	return m_polyFlags.Visible;
+	return (m_polyflags & VISIBLE) != 0;
 }
 
-
+void RAS_Polygon::SetVisible(bool visible)
+{
+	if(visible) m_polyflags |= VISIBLE;
+	else m_polyflags &= ~VISIBLE;
+}
 
 bool RAS_Polygon::IsCollider()
 {
-	return m_polyFlags.Collider;
+	return (m_polyflags & COLLIDER) != 0;
 }
 
-
-
-void RAS_Polygon::SetCollider(bool col)
+void RAS_Polygon::SetCollider(bool visible)
 {
-	m_polyFlags.Collider = col;
+	if(visible) m_polyflags |= COLLIDER;
+	else m_polyflags &= ~COLLIDER;
 }
 
-
-
-KX_VertexIndex& RAS_Polygon::GetVertexIndexBase()
+RAS_MaterialBucket* RAS_Polygon::GetMaterial()
 {
-	return m_vertexindexbase;
+	return m_bucket;
 }
 
-
-
-RAS_MaterialBucket*	RAS_Polygon::GetMaterial()
+RAS_DisplayArray* RAS_Polygon::GetDisplayArray()
 {
-	return m_bucket;
+	return m_darray;
 }
diff --git a/source/gameengine/Rasterizer/RAS_Polygon.h b/source/gameengine/Rasterizer/RAS_Polygon.h
index 7ce7926a816..18526ba45f7 100644
--- a/source/gameengine/Rasterizer/RAS_Polygon.h
+++ b/source/gameengine/Rasterizer/RAS_Polygon.h
@@ -35,55 +35,47 @@
 #include <vector>
 using namespace std;
 
-
-//
-// Bitfield that stores the flags for each CValue derived class
-//
-struct PolygonFlags {
-	PolygonFlags() :
-		Visible(true),
-		Collider(true)
-	{
-	}
-	unsigned char Visible : 1;
-	unsigned char Collider : 1;
-	//int Visible : 1;
-	//int Collider : 1;
-};
+/* polygon flags */
 
 class RAS_Polygon
 {
+	/* location */
 	RAS_MaterialBucket*			m_bucket;
-	KX_VertexIndex				m_vertexindexbase;
-	int							m_numverts;
-	int							m_edgecode;
-	PolygonFlags				m_polyFlags;
-	
+	RAS_DisplayArray*			m_darray;
+	unsigned short				m_offset[4];
+	unsigned short				m_numvert;
+
+	/* flags */
+	unsigned char				m_edgecode;
+	unsigned char				m_polyflags;
 
 public:
-	RAS_Polygon(RAS_MaterialBucket* bucket,
-				bool visible,
-				int numverts,
-				int vtxarrayindex) ;
+	enum {
+		VISIBLE = 1,
+		COLLIDER = 2
+	};
+
+	RAS_Polygon(RAS_MaterialBucket* bucket, RAS_DisplayArray* darray, int numvert);
 	virtual ~RAS_Polygon() {};
 	
-//	RAS_TexVert* GetVertex(int index);
 	int					VertexCount();
-	void				SetVertex(int i, unsigned int vertexindex); //const MT_Point3& xyz,const MT_Point2& uv,const unsigned int rgbacolor,const MT_Vector3& normal)
-	
-	const KX_VertexIndex& GetIndexBase();
+	RAS_TexVert*		GetVertex(int i);
 
-	void				SetVisibleWireframeEdges(int edgecode);
+	void				SetVertexOffset(int i, unsigned short offset);
+	int					GetVertexOffset(int i);
+	
 	// each bit is for a visible edge, starting with bit 1 for the first edge, bit 2 for second etc.
 	int					GetEdgeCode();
+	void				SetEdgeCode(int edgecode);
 	
 	bool				IsVisible();
+	void				SetVisible(bool visible);
+
 	bool				IsCollider();
-	void				SetCollider(bool col);
+	void				SetCollider(bool collider);
 
-	KX_VertexIndex&		GetVertexIndexBase();
 	RAS_MaterialBucket*	GetMaterial();
-
+	RAS_DisplayArray*	GetDisplayArray();
 };
 
 #endif
diff --git a/source/gameengine/Rasterizer/RAS_TexVert.cpp b/source/gameengine/Rasterizer/RAS_TexVert.cpp
index 935633dc636..d6f1fe912be 100644
--- a/source/gameengine/Rasterizer/RAS_TexVert.cpp
+++ b/source/gameengine/Rasterizer/RAS_TexVert.cpp
@@ -27,12 +27,7 @@
  */
 
 #include "RAS_TexVert.h"
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#define SHORT(x) short(x*32767.0)
+#include "MT_Matrix4x4.h"
 
 RAS_TexVert::RAS_TexVert(const MT_Point3& xyz,
 						 const MT_Point2& uv,
@@ -40,7 +35,7 @@ RAS_TexVert::RAS_TexVert(const MT_Point3& xyz,
 						 const MT_Vector4& tangent,
 						 const unsigned int rgba,
 						 const MT_Vector3& normal,
-						 const short flag,
+						 const bool flat,
 						 const unsigned int origindex)
 {
 	xyz.getValue(m_localxyz);
@@ -49,7 +44,7 @@ RAS_TexVert::RAS_TexVert(const MT_Point3& xyz,
 	SetRGBA(rgba);
 	SetNormal(normal);
 	tangent.getValue(m_tangent);
-	m_flag = flag;
+	m_flag = (flat)? FLAT: 0;
 	m_origindex = origindex;
 	m_unit = 2;
 }
@@ -101,7 +96,7 @@ void RAS_TexVert::SetFlag(const short flag)
 
 void RAS_TexVert::SetUnit(const unsigned int u)
 {
-	m_unit = u<=TV_MAX?u:TV_MAX;
+	m_unit = u<=MAX_UNIT?u:MAX_UNIT;
 }
 
 void RAS_TexVert::SetNormal(const MT_Vector3& normal)
@@ -109,12 +104,18 @@ void RAS_TexVert::SetNormal(const MT_Vector3& normal)
 	normal.getValue(m_normal);
 }
 
+void RAS_TexVert::SetTangent(const MT_Vector3& tangent)
+{
+	tangent.getValue(m_tangent);
+}
+
 // compare two vertices, and return TRUE if both are almost identical (they can be shared)
 bool RAS_TexVert::closeTo(const RAS_TexVert* other)
 {
 	return (m_flag == other->m_flag &&
 		m_rgba == other->m_rgba &&
 		MT_fuzzyEqual(MT_Vector3(m_normal), MT_Vector3(other->m_normal)) &&
+		MT_fuzzyEqual(MT_Vector3(m_tangent), MT_Vector3(other->m_tangent)) &&
 		MT_fuzzyEqual(MT_Vector2(m_uv1), MT_Vector2(other->m_uv1)) &&
 		MT_fuzzyEqual(MT_Vector2(m_uv2), MT_Vector2(other->m_uv2)) && // p --
 		MT_fuzzyEqual(MT_Vector3(m_localxyz), MT_Vector3(other->m_localxyz))) ;
@@ -131,11 +132,10 @@ unsigned int RAS_TexVert::getUnit() const
 	return m_unit;
 }
 
-
-void RAS_TexVert::getOffsets(void* &xyz, void* &uv1, void* &rgba, void* &normal) const
+void RAS_TexVert::Transform(const MT_Matrix4x4& mat, const MT_Matrix4x4& nmat)
 {
-	xyz = (void *) m_localxyz;
-	uv1 = (void *) m_uv1;
-	rgba = (void *) &m_rgba;
-	normal = (void *) m_normal;
+	SetXYZ((mat*MT_Vector4(m_localxyz[0], m_localxyz[1], m_localxyz[2], 1.0)).getValue());
+	SetNormal((nmat*MT_Vector4(m_normal[0], m_normal[1], m_normal[2], 1.0)).getValue());
+	SetTangent((nmat*MT_Vector4(m_tangent[0], m_tangent[1], m_tangent[2], 1.0)).getValue());
 }
+
diff --git a/source/gameengine/Rasterizer/RAS_TexVert.h b/source/gameengine/Rasterizer/RAS_TexVert.h
index bf092b4b230..4ec4db19e53 100644
--- a/source/gameengine/Rasterizer/RAS_TexVert.h
+++ b/source/gameengine/Rasterizer/RAS_TexVert.h
@@ -37,11 +37,6 @@
 static MT_Point3 g_pt3;
 static MT_Point2 g_pt2;
 
-#define TV_CALCFACENORMAL	0x0001
-#define TV_2NDUV			0x0002
-
-#define TV_MAX				3//match Def in BL_Material.h
-
 class RAS_TexVert
 {
 	
@@ -59,6 +54,12 @@ class RAS_TexVert
 	// 32 bytes total size, fits nice = 56 = not fit nice.
 	// We'll go for 64 bytes total size - 24 bytes left.
 public:
+	enum {
+		FLAT = 1,
+		SECOND_UV = 2,
+		MAX_UNIT = 8
+	};
+
 	short getFlag() const;
 	unsigned int getUnit() const;
 	
@@ -70,7 +71,7 @@ public:
 				const MT_Vector4& tangent,
 				const unsigned int rgba,
 				const MT_Vector3& normal,
-				const short flag,
+				const bool flat,
 				const unsigned int origindex);
 	~RAS_TexVert() {};
 
@@ -82,7 +83,7 @@ public:
 		return m_uv2;
 	};
 
-	const float* getLocalXYZ() const { 
+	const float* getXYZ() const { 
 		return m_localxyz;
 	};
 	
@@ -108,20 +109,19 @@ public:
 
 	void				SetRGBA(const unsigned int rgba);
 	void				SetNormal(const MT_Vector3& normal);
+	void				SetTangent(const MT_Vector3& tangent);
 	void				SetFlag(const short flag);
 	void				SetUnit(const unsigned u);
 	
 	void				SetRGBA(const MT_Vector4& rgba);
 	const MT_Point3&	xyz();
 
-	// compare two vertices, and return TRUE if both are almost identical (they can be shared)
-	bool				closeTo(const RAS_TexVert* other);
+	void				Transform(const class MT_Matrix4x4& mat,
+	                              const class MT_Matrix4x4& nmat);
 
-	bool				closeTo(const MT_Point3& otherxyz,
-								const MT_Point2& otheruv,
-								const unsigned int otherrgba,
-								short othernormal[3]) const;
-	void getOffsets(void*&xyz, void *&uv1, void *&rgba, void *&normal) const;
+	// compare two vertices, to test if they can be shared, used for
+	// splitting up based on uv's, colors, etc
+	bool				closeTo(const RAS_TexVert* other);
 };
 
 #endif //__RAS_TEXVERT
diff --git a/source/gameengine/Rasterizer/SConscript b/source/gameengine/Rasterizer/SConscript
index e6bc657ed6d..a024f7e0ee6 100644
--- a/source/gameengine/Rasterizer/SConscript
+++ b/source/gameengine/Rasterizer/SConscript
@@ -3,11 +3,8 @@ Import ('env')
 
 sources = env.Glob('*.cpp')
 
-if env['WITH_BF_GLEXT'] == 1:
-        env['CPPFLAGS'].append('-DWITH_GLEXT')
 
-
-incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/BlenderRoutines #extern/glew/include #source/gameengine/Expressions'
+incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/BlenderRoutines #extern/glew/include #source/gameengine/Expressions #source/blender/blenkernel #source/blender/makesdna'
 incs += ' ' + env['BF_PYTHON_INC']
 
 if env['OURPLATFORM']=='win32-vc':