Merge of trunk into blender 2.5:

svn merge https://svn.blender.org/svnroot/bf-blender/trunk/blender -r12987:17416

Issues:
* GHOST/X11 had conflicting changes. Some code was added in 2.5, which was
  later added in trunk also, but reverted partially, specifically revision
  16683. I have left out this reversion in the 2.5 branch since I think it is
  needed there.
  http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=16683
* Scons had various conflicting changes, I decided to go with trunk version
  for everything except priorities and some library renaming.
* In creator.c, there were various fixes and fixes for fixes related to the -w
  -W and -p options. In 2.5 -w and -W is not coded yet, and -p is done
  differently. Since this is changed so much, and I don't think those fixes
  would be needed in 2.5, I've left them out.
* Also in creator.c: there was code for a python bugfix where the screen was not
  initialized when running with -P. The code that initializes the screen there
  I had to disable, that can't work in 2.5 anymore but left it commented as a
  reminder.

Further I had to disable some new function calls. using src/ and python/, as
was done already in this branch, disabled function calls:
* bpath.c: error reporting
* BME_conversions.c: editmesh conversion functions.
* SHD_dynamic: disabled almost completely, there is no python/.
* KX_PythonInit.cpp and Ketsji/ build files: Mathutils is not there, disabled.
* text.c: clipboard copy call.
* object.c: OB_SUPPORT_MATERIAL.
* DerivedMesh.c and subsurf_ccg, stipple_quarttone.

Still to be done:
* Go over files and functions that were moved to a different location but could
  still use changes that were done in trunk.

1 files changed, 127 insertions, 153 deletions

diff --git a/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp b/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp
index 6a098cc5491..1797d6c1a0f 100644
--- a/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp
+++ b/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp
@@ -26,18 +26,7 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-#include "KX_BlenderRenderTools.h"
-
-#ifdef WIN32
-// OpenGL gl.h needs 'windows.h' on windows platforms 
-#include <windows.h>
-#endif //WIN32
-#ifdef __APPLE__
-#define GL_GLEXT_LEGACY 1
-#include <OpenGL/gl.h>
-#else
-#include <GL/gl.h>
-#endif
+#include "GL/glew.h"
 
 #include "RAS_IRenderTools.h"
 #include "RAS_IRasterizer.h"
@@ -45,24 +34,22 @@
 #include "RAS_ICanvas.h"
 #include "RAS_GLExtensionManager.h"
 
-// next two includes/dependencies come from the shadow feature
-// it needs the gameobject and the sumo physics scene for a raycast
 #include "KX_GameObject.h"
-
-#include "KX_BlenderPolyMaterial.h"
 #include "KX_PolygonMaterial.h"
 #include "KX_BlenderMaterial.h"
+#include "KX_RayCast.h"
+#include "KX_IPhysicsController.h"
 
-#include "Value.h"
+#include "PHY_IPhysicsEnvironment.h"
 
-#include "KX_BlenderGL.h" // for text printing
 #include "STR_String.h"
-#include "RAS_BucketManager.h" // for polymaterial (needed for textprinting)
 
-#include "KX_RayCast.h"
-#include "KX_IPhysicsController.h"
-#include "PHY_IPhysicsEnvironment.h"
-#include "KX_Scene.h"
+#include "GPU_draw.h"
+
+#include "KX_BlenderGL.h" // for text printing
+#include "KX_BlenderRenderTools.h"
+
+unsigned int KX_BlenderRenderTools::m_numgllights;
 
 KX_BlenderRenderTools::KX_BlenderRenderTools()
 {
@@ -71,61 +58,98 @@ KX_BlenderRenderTools::KX_BlenderRenderTools()
 		m_numgllights = 8;
 }
 
-/**
-ProcessLighting performs lighting on objects. the layer is a bitfield that contains layer information.
-There are 20 'official' layers in blender.
-A light is applied on an object only when they are in the same layer.
-OpenGL has a maximum of 8 lights (simultaneous), so 20 * 8 lights are possible in a scene.
-*/
+KX_BlenderRenderTools::~KX_BlenderRenderTools()
+{
+}
 
-int	KX_BlenderRenderTools::ProcessLighting(int layer) 
+void KX_BlenderRenderTools::BeginFrame(RAS_IRasterizer* rasty)
 {
-	
-	int result = false;
+	m_clientobject = NULL;
+	m_lastlightlayer = -1;
+	m_lastlighting = false;
+	DisableOpenGLLights();
+}
 
-	if (layer < 0)
-	{
-		DisableOpenGLLights();
-		result = false;
-	} else
+void KX_BlenderRenderTools::EndFrame(RAS_IRasterizer* rasty)
+{
+}
+
+/* ProcessLighting performs lighting on objects. the layer is a bitfield that
+ * contains layer information. There are 20 'official' layers in blender. A
+ * light is applied on an object only when they are in the same layer. OpenGL
+ * has a maximum of 8 lights (simultaneous), so 20 * 8 lights are possible in
+ * a scene. */
+
+void KX_BlenderRenderTools::ProcessLighting(int layer, const MT_Transform& viewmat)
+{
+	if(m_lastlightlayer == layer)
+		return;
+
+	m_lastlightlayer = layer;
+
+	bool enable = false;
+
+	if (layer >= 0)
 	{
 		if (m_clientobject)
 		{
-			if (applyLights(layer))
-			{
-				EnableOpenGLLights();
-				result = true;
-			} else
-			{
-				DisableOpenGLLights();
-				result = false;
-			}			
+			if (layer == RAS_LIGHT_OBJECT_LAYER)
+				layer = static_cast<KX_GameObject*>(m_clientobject)->GetLayer();
+
+			enable = applyLights(layer, viewmat);
 		}
 	}
-	return result;
-	
-	
+
+	if(enable)
+		EnableOpenGLLights();
+	else
+		DisableOpenGLLights();
 }
 
+void KX_BlenderRenderTools::EnableOpenGLLights()
+{
+	if(m_lastlighting == true)
+		return;
 
-void KX_BlenderRenderTools::BeginFrame(RAS_IRasterizer* rasty)
+	glEnable(GL_LIGHTING);
+	glEnable(GL_COLOR_MATERIAL);
+
+	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
+	glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, true);
+	if (GLEW_EXT_separate_specular_color || GLEW_VERSION_1_2)
+		glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
+	
+	m_lastlighting = true;
+}
+
+void KX_BlenderRenderTools::DisableOpenGLLights()
 {
-	m_clientobject = NULL;
-	m_lastblenderobject = NULL;
-	m_lastblenderlights = false;
-	m_lastlayer = -1;
+	if(m_lastlighting == false)
+		return;
+
+	glDisable(GL_LIGHTING);
+	glDisable(GL_COLOR_MATERIAL);
+
 	m_lastlighting = false;
-	m_modified = true;
-	DisableOpenGLLights();
+}
+
 
+void KX_BlenderRenderTools::SetClientObject(RAS_IRasterizer *rasty, void* obj)
+{
+	if (m_clientobject != obj)
+	{
+		bool ccw = (obj == NULL || !((KX_GameObject*)obj)->IsNegativeScaling());
+		rasty->SetFrontFace(ccw);
 
+		m_clientobject = obj;
+	}
 }
 
-bool KX_BlenderRenderTools::RayHit(KX_ClientObjectInfo* client, MT_Point3& hit_point, MT_Vector3& hit_normal, void * const data)
+bool KX_BlenderRenderTools::RayHit(KX_ClientObjectInfo* client, KX_RayCast* result, void * const data)
 {
 	double* const oglmatrix = (double* const) data;
-	MT_Point3 resultpoint(hit_point);
-	MT_Vector3 resultnormal(hit_normal);
+	MT_Point3 resultpoint(result->m_hitPoint);
+	MT_Vector3 resultnormal(result->m_hitNormal);
 	MT_Vector3 left(oglmatrix[0],oglmatrix[1],oglmatrix[2]);
 	MT_Vector3 dir = -(left.cross(resultnormal)).safe_normalized();
 	left = (dir.cross(resultnormal)).safe_normalized();
@@ -172,7 +196,7 @@ void KX_BlenderRenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmat
 		MT_Vector3 dir = (campos - objpos).safe_normalized();
 		MT_Vector3 up(0,0,1.0);
 
-		KX_GameObject* gameobj = (KX_GameObject*) this->m_clientobject;
+		KX_GameObject* gameobj = (KX_GameObject*)m_clientobject;
 		// get scaling of halo object
 		MT_Vector3  size = gameobj->GetSGNode()->GetLocalScale();
 		
@@ -208,7 +232,7 @@ void KX_BlenderRenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmat
 		{
 			// shadow must be cast to the ground, physics system needed here!
 			MT_Point3 frompoint(oglmatrix[12],oglmatrix[13],oglmatrix[14]);
-			KX_GameObject *gameobj = (KX_GameObject*) this->m_clientobject;
+			KX_GameObject *gameobj = (KX_GameObject*)m_clientobject;
 			MT_Vector3 direction = MT_Vector3(0,0,-1);
 
 			direction.normalize();
@@ -226,9 +250,8 @@ void KX_BlenderRenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmat
 			if (parent)
 				parent->Release();
 				
-			MT_Point3 resultpoint;
-			MT_Vector3 resultnormal;
-			if (!KX_RayCast::RayTest(physics_controller, physics_environment, frompoint, topoint, resultpoint, resultnormal, KX_RayCast::Callback<KX_BlenderRenderTools>(this, oglmatrix)))
+			KX_RayCast::Callback<KX_BlenderRenderTools> callback(this, physics_controller, oglmatrix);
+			if (!KX_RayCast::RayTest(physics_environment, frompoint, topoint, callback))
 			{
 				// couldn't find something to cast the shadow on...
 				glMultMatrixd(oglmatrix);
@@ -243,13 +266,29 @@ void KX_BlenderRenderTools::applyTransform(RAS_IRasterizer* rasty,double* oglmat
 }
 
 
-/**
-Render Text renders text into a (series of) polygon, using a texture font,
-Each character consists of one polygon (one quad or two triangles)
-*/
-void	KX_BlenderRenderTools::RenderText(int mode,RAS_IPolyMaterial* polymat,float v1[3],float v2[3],float v3[3],float v4[3])
+void KX_BlenderRenderTools::RenderText2D(RAS_TEXT_RENDER_MODE mode,
+										 const char* text,
+										 int xco,
+										 int yco,									 
+										 int width,
+										 int height)
+{
+	STR_String tmpstr(text);
+
+	if(mode == RAS_IRenderTools::RAS_TEXT_PADDED)
+		BL_print_gamedebug_line_padded(tmpstr.Ptr(), xco, yco, width, height);
+	else
+		BL_print_gamedebug_line(tmpstr.Ptr(), xco, yco, width, height);
+}
+
+/* Render Text renders text into a (series of) polygon, using a texture font,
+ * Each character consists of one polygon (one quad or two triangles) */
+
+void KX_BlenderRenderTools::RenderText(
+	int mode,
+	RAS_IPolyMaterial* polymat,
+	float v1[3], float v2[3], float v3[3], float v4[3], int glattrib)
 {
-		
 	STR_String mytext = ((CValue*)m_clientobject)->GetPropertyText("Text");
 	
 	const unsigned int flag = polymat->GetFlag();
@@ -266,67 +305,9 @@ void	KX_BlenderRenderTools::RenderText(int mode,RAS_IPolyMaterial* polymat,float
 		col = blenderpoly->GetMCol();
 	}
 	
-	BL_RenderText( mode,mytext,mytext.Length(),tface,col,v1,v2,v3,v4);
-	
-}
-
-
-
-KX_BlenderRenderTools::~KX_BlenderRenderTools()
-{
-};
-	
-	
-void	KX_BlenderRenderTools::EndFrame(RAS_IRasterizer* rasty)
-{
-}
-	
-
-	
-void KX_BlenderRenderTools::DisableOpenGLLights()
-{
-	glDisable(GL_LIGHTING);
-	glDisable(GL_COLOR_MATERIAL);
-}
-
-	
-void KX_BlenderRenderTools::EnableOpenGLLights()
-{
-	glEnable(GL_LIGHTING);
-	
-	glEnable(GL_COLOR_MATERIAL);
-	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
-	glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, true);
-	if (bgl::QueryExtension(bgl::_GL_EXT_separate_specular_color) || bgl::QueryVersion(1, 2))
-		glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
-
-}
-	
-
-/**
- * Rendering text using 2D bitmap functionality.  
- */
-void KX_BlenderRenderTools::RenderText2D(RAS_TEXT_RENDER_MODE mode,
-										 const char* text,
-										 int xco,
-										 int yco,									 
-										 int width,
-										 int height)
-{
-	switch (mode) {
-	case RAS_IRenderTools::RAS_TEXT_PADDED: {
-		STR_String tmpstr(text);
-		BL_print_gamedebug_line_padded(tmpstr.Ptr(),xco,yco,width,height);
-		break;
-	}
-	default: {
-		STR_String tmpstr(text);
-		BL_print_gamedebug_line(tmpstr.Ptr(),xco,yco,width,height);
-	}
-	}
+	GPU_render_text(tface, mode, mytext, mytext.Length(), col, v1, v2, v3, v4, glattrib);
 }
 
-	
 
 void KX_BlenderRenderTools::PushMatrix()
 {
@@ -339,14 +320,13 @@ void KX_BlenderRenderTools::PopMatrix()
 }
 
 
-
-int	KX_BlenderRenderTools::applyLights(int objectlayer)
+int KX_BlenderRenderTools::applyLights(int objectlayer, const MT_Transform& viewmat)
 {
-// taken from blender source, incompatibility between Blender Object / GameObject	
-	
+	// taken from blender source, incompatibility between Blender Object / GameObject	
+	float glviewmat[16];
 	unsigned int count;
 	float vec[4];
-		
+
 	vec[3]= 1.0;
 	
 	for(count=0; count<m_numgllights; count++)
@@ -354,9 +334,11 @@ int	KX_BlenderRenderTools::applyLights(int objectlayer)
 	
 	//std::vector<struct	RAS_LightObject*> m_lights;
 	std::vector<struct	RAS_LightObject*>::iterator lit = m_lights.begin();
+
+	viewmat.getValue(glviewmat);
 	
 	glPushMatrix();
-	glLoadMatrixf(m_viewmat);
+	glLoadMatrixf(glviewmat);
 	for (lit = m_lights.begin(), count = 0; !(lit==m_lights.end()) && count < m_numgllights; ++lit)
 	{
 		RAS_LightObject* lightdata = (*lit);
@@ -424,7 +406,6 @@ int	KX_BlenderRenderTools::applyLights(int objectlayer)
 			glEnable((GLenum)(GL_LIGHT0+count));
 
 			count++;
-			
 		}
 	}
 	glPopMatrix();
@@ -433,22 +414,6 @@ int	KX_BlenderRenderTools::applyLights(int objectlayer)
 
 }
 
-
-
-RAS_IPolyMaterial* KX_BlenderRenderTools::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)
-{
-	assert(!"Deprecated");
-/*	return new KX_BlenderPolyMaterial(
-
-		texname,
-		ba,matname,tile,tilexrep,tileyrep,mode,transparant,zsort, lightlayer
-		,bIsTriangle,clientobject,(struct MTFace*)tface);*/
-	return NULL;
-}
-
 void KX_BlenderRenderTools::MotionBlur(RAS_IRasterizer* rasterizer)
 {
 	int state = rasterizer->GetMotionBlurState();
@@ -472,4 +437,13 @@ void KX_BlenderRenderTools::MotionBlur(RAS_IRasterizer* rasterizer)
 	}
 }
 
-unsigned int KX_BlenderRenderTools::m_numgllights;
+void KX_BlenderRenderTools::Update2DFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text)
+{
+	m_filtermanager.EnableFilter(propNames, gameObj, filtermode, pass, text);
+}
+
+void KX_BlenderRenderTools::Render2DFilters(RAS_ICanvas* canvas)
+{
+	m_filtermanager.RenderFilters(canvas);
+}
+