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.

1 files changed, 128 insertions, 85 deletions

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