BGE Python API

- More verbose error messages.
- BL_Shader wasnt setting error messages on some errors
- FilterNormal depth attribute was checking for float which is bad because scripts often expect ints assigned to float attributes.
- Added a check to PyVecTo for a tuple rather then always using a generic python sequence. On my system this is over 2x faster with an optmized build.

15 files changed, 212 insertions, 165 deletions

diff --git a/source/gameengine/Ketsji/BL_Shader.cpp b/source/gameengine/Ketsji/BL_Shader.cpp
index 01b6805ae7a..88d920043e0 100644
--- a/source/gameengine/Ketsji/BL_Shader.cpp
+++ b/source/gameengine/Ketsji/BL_Shader.cpp
@@ -858,7 +858,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
 		Py_RETURN_NONE;
 	}
 	if(mShader==0) {
-		PyErr_Format(PyExc_TypeError, "invalid shader object");
+		PyErr_SetString(PyExc_TypeError, "shader.validate(): BL_Shader, invalid shader object");
 		return NULL;
 	}
 	int stat = 0;
@@ -1175,7 +1175,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 					}break;
 				default:
 					{
-						PyErr_Format(PyExc_TypeError, "Invalid list size");
+						PyErr_SetString(PyExc_TypeError, "shader.setUniform4i(name, ix,iy,iz, iw): BL_Shader. invalid list size");
 						return NULL;
 					}break;
 				}
@@ -1185,7 +1185,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 	return NULL;
 }
 
-KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3 or list4) )")
+KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( uniform_name, (list2 or list3 or list4) )")
 {
 	if(mError) {
 		Py_RETURN_NONE;
@@ -1194,70 +1194,84 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3
 	PyObject *listPtr =0;
 	int array_data[4] = {0,0,0,0};
 
-	if(PyArg_ParseTuple(args, "sO:setUniformiv", &uniform, &listPtr))
+	if(!PyArg_ParseTuple(args, "sO:setUniformiv", &uniform, &listPtr))
+		return NULL;
+	
+	int loc = GetUniformLocation(uniform);
+	
+	if(loc == -1) {
+		PyErr_SetString(PyExc_TypeError, "shader.setUniformiv(...): BL_Shader, first string argument is not a valid uniform value");
+		return NULL;
+	}
+	
+	if(!PySequence_Check(listPtr)) {
+		PyErr_SetString(PyExc_TypeError, "shader.setUniformiv(...): BL_Shader, second argument is not a sequence");
+		return NULL;
+	}
+	
+	unsigned int list_size = PySequence_Size(listPtr);
+	
+	for(unsigned int i=0; (i<list_size && i<4); i++)
 	{
-		int loc = GetUniformLocation(uniform);
-		if(loc != -1)
+		PyObject *item = PySequence_GetItem(listPtr, i);
+		array_data[i] = PyInt_AsLong(item);
+		Py_DECREF(item);
+	}
+	
+	if(PyErr_Occurred()) {
+		PyErr_SetString(PyExc_TypeError, "shader.setUniformiv(...): BL_Shader, one or more values in the list is not an int");
+		return NULL;
+	}
+	
+	/* Sanity checks done! */
+	
+	switch(list_size)
+	{
+	case 2:
 		{
-			if(PySequence_Check(listPtr))
-			{
-				unsigned int list_size = PySequence_Size(listPtr);
-				
-				for(unsigned int i=0; (i<list_size && i<4); i++)
-				{
-					PyObject *item = PySequence_GetItem(listPtr, i);
-					array_data[i] = PyInt_AsLong(item);
-					Py_DECREF(item);
-				}
-				switch(list_size)
-				{
-				case 2:
-					{
-						int array2[2] = { array_data[0],array_data[1]};
+			int array2[2] = { array_data[0],array_data[1]};
 #ifdef SORT_UNIFORMS
-						SetUniformiv(loc, BL_Uniform::UNI_INT2, array2, sizeof(int)*2);
+			SetUniformiv(loc, BL_Uniform::UNI_INT2, array2, sizeof(int)*2);
 #else
-						SetUniform(loc, array2, 2);						
+			SetUniform(loc, array2, 2);						
 #endif
-						Py_RETURN_NONE;
-					} break;
-				case 3:
-					{
-						int array3[3] = { array_data[0],array_data[1],array_data[2] };
+			Py_RETURN_NONE;
+		} break;
+	case 3:
+		{
+			int array3[3] = { array_data[0],array_data[1],array_data[2] };
 #ifdef SORT_UNIFORMS
-						SetUniformiv(loc, BL_Uniform::UNI_INT3, array3, sizeof(int)*3);
-						
+			SetUniformiv(loc, BL_Uniform::UNI_INT3, array3, sizeof(int)*3);
+			
 #else
-						SetUniform(loc, array3, 3);	
+			SetUniform(loc, array3, 3);	
 #endif
-						Py_RETURN_NONE;
-					}break;
-				case 4:
-					{
-						int array4[4] = { array_data[0],array_data[1],array_data[2],array_data[3] };
+			Py_RETURN_NONE;
+		}break;
+	case 4:
+		{
+			int array4[4] = { array_data[0],array_data[1],array_data[2],array_data[3] };
 #ifdef SORT_UNIFORMS
-						SetUniformiv(loc, BL_Uniform::UNI_INT4, array4, sizeof(int)*4);
-						
+			SetUniformiv(loc, BL_Uniform::UNI_INT4, array4, sizeof(int)*4);
+			
 #else
-						SetUniform(loc, array4, 4);	
+			SetUniform(loc, array4, 4);	
 #endif
-						Py_RETURN_NONE;
-					}break;
-				default:
-					{
-						PyErr_Format(PyExc_TypeError, "Invalid list size");
-						return NULL;
-					}break;
-				}
-			}
-		}
+			Py_RETURN_NONE;
+		}break;
+	default:
+		{
+			PyErr_SetString(PyExc_TypeError, "shader.setUniformiv(...): BL_Shader, second argument, invalid list size, expected an int list between 2 and 4");
+			return NULL;
+		}break;
 	}
-	return NULL;
+	
+	Py_RETURN_NONE;
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix4, 
-"setUniformMatrix4(uniform-name, mat-4x4, transpose(row-major=true, col-major=false)" )
+"setUniformMatrix4(uniform_name, mat-4x4, transpose(row-major=true, col-major=false)" )
 {
 	if(mError) {
 		Py_RETURN_NONE;
@@ -1273,30 +1287,38 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix4,
 	const char *uniform="";
 	PyObject *matrix=0;
 	int transp=1; // MT_ is row major so transpose by default....
-	if(PyArg_ParseTuple(args, "sO|i:setUniformMatrix4",&uniform, &matrix,&transp))
-	{
-		int loc = GetUniformLocation(uniform);
-		if(loc != -1)
-		{
-			MT_Matrix4x4 mat;
-			if (PyMatTo(matrix, mat))
-			{
+	
+	if(!PyArg_ParseTuple(args, "sO|i:setUniformMatrix4",&uniform, &matrix,&transp))
+		return NULL;
+
+	int loc = GetUniformLocation(uniform);
+	
+	if(loc == -1) {
+		PyErr_SetString(PyExc_TypeError, "shader.setUniformMatrix4(...): BL_Shader, first string argument is not a valid uniform value");
+		return NULL;
+	}
+	
+	MT_Matrix4x4 mat;
+	
+	if (!PyMatTo(matrix, mat)) {
+		PyErr_SetString(PyExc_TypeError, "shader.setUniformMatrix4(...): BL_Shader, second argument cannot be converted into a 4x4 matrix");
+		return NULL;
+	}
+	
+	/* Sanity checks done! */
+
 #ifdef SORT_UNIFORMS
-				mat.getValue(matr);
-				SetUniformfv(loc, BL_Uniform::UNI_MAT4, matr, (sizeof(float)*16), (transp!=0) );
+	mat.getValue(matr);
+	SetUniformfv(loc, BL_Uniform::UNI_MAT4, matr, (sizeof(float)*16), (transp!=0) );
 #else
-				SetUniform(loc,mat,(transp!=0));
+	SetUniform(loc,mat,(transp!=0));
 #endif
-				Py_RETURN_NONE;
-			}
-		}
-	}
-	return NULL;
+	Py_RETURN_NONE;
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
-"setUniformMatrix3(uniform-name, list[3x3], transpose(row-major=true, col-major=false)" )
+"setUniformMatrix3(uniform_name, list[3x3], transpose(row-major=true, col-major=false)" )
 {
 	if(mError) {
 		Py_RETURN_NONE;
@@ -1311,25 +1333,32 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 	const char *uniform="";
 	PyObject *matrix=0;
 	int transp=1; // MT_ is row major so transpose by default....
-	if(PyArg_ParseTuple(args, "sO|i:setUniformMatrix3",&uniform, &matrix,&transp))
-	{
-		int loc = GetUniformLocation(uniform);
-		if(loc != -1)
-		{
-			MT_Matrix3x3 mat;
-			if (PyMatTo(matrix, mat))
-			{
+	if(!PyArg_ParseTuple(args, "sO|i:setUniformMatrix3",&uniform, &matrix,&transp))
+		return NULL;
+	
+	int loc = GetUniformLocation(uniform);
+	
+	if(loc == -1) {
+		PyErr_SetString(PyExc_TypeError, "shader.setUniformMatrix3(...): BL_Shader, first string argument is not a valid uniform value");
+		return NULL;
+	}
+	
+	
+	MT_Matrix3x3 mat;
+	
+	if (!PyMatTo(matrix, mat)) {
+		PyErr_SetString(PyExc_TypeError, "shader.setUniformMatrix3(...): BL_Shader, second argument cannot be converted into a 3x3 matrix");
+		return NULL;
+	}
+	
+
 #ifdef SORT_UNIFORMS
-				mat.getValue(matr);
-				SetUniformfv(loc, BL_Uniform::UNI_MAT3, matr, (sizeof(float)*9), (transp!=0) );
+	mat.getValue(matr);
+	SetUniformfv(loc, BL_Uniform::UNI_MAT3, matr, (sizeof(float)*9), (transp!=0) );
 #else
-				SetUniform(loc,mat,(transp!=0));
+	SetUniform(loc,mat,(transp!=0));
 #endif
-				Py_RETURN_NONE;
-			}
-		}
-	}
-	return NULL;
+	Py_RETURN_NONE;
 }
 
 KX_PYMETHODDEF_DOC( BL_Shader, setAttrib, "setAttrib(enum)" )
@@ -1337,18 +1366,20 @@ KX_PYMETHODDEF_DOC( BL_Shader, setAttrib, "setAttrib(enum)" )
 	if(mError) {
 		Py_RETURN_NONE;
 	}
+	
 	int attr=0;
-	if(PyArg_ParseTuple(args, "i:setAttrib", &attr )) {
-		if(mShader==0) {
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		mAttr=SHD_TANGENT;
-		glUseProgramObjectARB(mShader);
-		glBindAttribLocationARB(mShader, mAttr, "Tangent");
-		Py_RETURN_NONE;
+	
+	if(!PyArg_ParseTuple(args, "i:setAttrib", &attr ))
+		return NULL;
+	
+	if(mShader==0) {
+		PyErr_SetString(PyExc_ValueError, "shader.setAttrib() BL_Shader, invalid shader object");
+		return NULL;
 	}
-	return NULL;
+	mAttr=SHD_TANGENT; /* What the heck is going on here - attr is just ignored??? - Campbell */
+	glUseProgramObjectARB(mShader);
+	glBindAttribLocationARB(mShader, mAttr, "Tangent");
+	Py_RETURN_NONE;
 }
 
 
diff --git a/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp b/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp
index 0c23c9b2712..7782567943e 100644
--- a/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp
+++ b/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp
@@ -262,7 +262,7 @@ PyObject* KX_NetworkMessageSensor::PySetSubjectFilterText(PyObject* value)
 	ShowDeprecationWarning("setSubjectFilterText()", "subject");
 	char* Subject = PyString_AsString(value);
 	if (Subject==NULL) {
-		PyErr_SetString(PyExc_TypeError, "expected a string message");
+		PyErr_SetString(PyExc_TypeError, "sensor.tsetSubjectFilterText(string): KX_NetworkMessageSensor, expected a string message");
 		return NULL;
 	}
 	
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
index 6722cd232fe..849332008ce 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
@@ -841,7 +841,7 @@ KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
 		}
 		Py_RETURN_NONE;
 	}
-	PyErr_Format(PyExc_ValueError, "GLSL Error");
+	PyErr_SetString(PyExc_ValueError, "material.getShader(): KX_BlenderMaterial, GLSL Error");
 	return NULL;
 }
 
@@ -907,7 +907,7 @@ KX_PYMETHODDEF_DOC( KX_BlenderMaterial, setBlending , "setBlending( GameLogic.sr
 			if(value_found[0] && value_found[1]) break;
 		}
 		if(!value_found[0] || !value_found[1]) {
-			PyErr_Format(PyExc_ValueError, "invalid enum.");
+			PyErr_SetString(PyExc_ValueError, "material.setBlending(int, int): KX_BlenderMaterial, invalid enum.");
 			return NULL;
 		}
 		mUserDefBlend = true;
diff --git a/source/gameengine/Ketsji/KX_Camera.cpp b/source/gameengine/Ketsji/KX_Camera.cpp
index db8186e4586..c8575424751 100644
--- a/source/gameengine/Ketsji/KX_Camera.cpp
+++ b/source/gameengine/Ketsji/KX_Camera.cpp
@@ -578,7 +578,7 @@ KX_PYMETHODDEF_DOC_VARARGS(KX_Camera, sphereInsideFrustum,
 		}
 	}
 
-	PyErr_SetString(PyExc_TypeError, "sphereInsideFrustum: Expected arguments: (center, radius)");
+	PyErr_SetString(PyExc_TypeError, "camera.sphereInsideFrustum(center, radius): KX_Camera, expected arguments: (center, radius)");
 	
 	return NULL;
 }
@@ -611,7 +611,7 @@ KX_PYMETHODDEF_DOC_O(KX_Camera, boxInsideFrustum,
 	unsigned int num_points = PySequence_Size(value);
 	if (num_points != 8)
 	{
-		PyErr_Format(PyExc_TypeError, "boxInsideFrustum: Expected eight (8) points, got %d", num_points);
+		PyErr_Format(PyExc_TypeError, "camera.boxInsideFrustum(box): KX_Camera, expected eight (8) points, got %d", num_points);
 		return NULL;
 	}
 	
@@ -650,7 +650,7 @@ KX_PYMETHODDEF_DOC_O(KX_Camera, pointInsideFrustum,
 		return PyInt_FromLong(PointInsideFrustum(point)); /* new ref */
 	}
 	
-	PyErr_SetString(PyExc_TypeError, "pointInsideFrustum: Expected point argument.");
+	PyErr_SetString(PyExc_TypeError, "camera.pointInsideFrustum(point): KX_Camera, expected point argument.");
 	return NULL;
 }
 
@@ -726,7 +726,7 @@ KX_PYMETHODDEF_DOC_O(KX_Camera, setProjectionMatrix,
 	MT_Matrix4x4 mat;
 	if (!PyMatTo(value, mat))
 	{
-		PyErr_SetString(PyExc_TypeError, "setProjectionMatrix: Expected 4x4 list as matrix argument.");
+		PyErr_SetString(PyExc_TypeError, "camera.setProjectionMatrix(matrix): KX_Camera, expected 4x4 list as matrix argument.");
 		return NULL;
 	}
 	
@@ -742,7 +742,7 @@ KX_PYMETHODDEF_DOC_O(KX_Camera, enableViewport,
 	int viewport = PyObject_IsTrue(value);
 	
 	if (viewport == -1) {
-		PyErr_SetString(PyExc_ValueError, "expected True/False or 0/1");
+		PyErr_SetString(PyExc_ValueError, "camera.enableViewport(bool): KX_Camera, expected True/False or 0/1");
 		return NULL;
 	}
 	
@@ -789,7 +789,7 @@ int KX_Camera::pyattr_set_perspective(void *self_v, const KX_PYATTRIBUTE_DEF *at
 	KX_Camera* self= static_cast<KX_Camera*>(self_v);
 	int param = PyObject_IsTrue( value );
 	if (param == -1) {
-		PyErr_SetString(PyExc_AttributeError, "expected True or False");
+		PyErr_SetString(PyExc_AttributeError, "camera.perspective = bool: KX_Camera, expected True/False or 0/1");
 		return -1;
 	}
 	
@@ -808,7 +808,7 @@ int KX_Camera::pyattr_set_lens(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef,
 	KX_Camera* self= static_cast<KX_Camera*>(self_v);
 	float param = PyFloat_AsDouble(value);
 	if (param == -1) {
-		PyErr_SetString(PyExc_AttributeError, "expected a float greater then zero");
+		PyErr_SetString(PyExc_AttributeError, "camera.lens = float: KX_Camera, expected a float greater then zero");
 		return -1;
 	}
 	
@@ -828,7 +828,7 @@ int KX_Camera::pyattr_set_near(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef,
 	KX_Camera* self= static_cast<KX_Camera*>(self_v);
 	float param = PyFloat_AsDouble(value);
 	if (param == -1) {
-		PyErr_SetString(PyExc_AttributeError, "expected a float greater then zero");
+		PyErr_SetString(PyExc_AttributeError, "camera.near = float: KX_Camera, expected a float greater then zero");
 		return -1;
 	}
 	
@@ -848,7 +848,7 @@ int KX_Camera::pyattr_set_far(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, P
 	KX_Camera* self= static_cast<KX_Camera*>(self_v);
 	float param = PyFloat_AsDouble(value);
 	if (param == -1) {
-		PyErr_SetString(PyExc_AttributeError, "expected a float greater then zero");
+		PyErr_SetString(PyExc_AttributeError, "camera.far = float: KX_Camera, expected a float greater then zero");
 		return -1;
 	}
 	
diff --git a/source/gameengine/Ketsji/KX_ConstraintActuator.cpp b/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
index 462abd3a584..1ce7fac0cfe 100644
--- a/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
+++ b/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
@@ -652,7 +652,7 @@ int KX_ConstraintActuator::pyattr_check_direction(void *self, const struct KX_PY
 	MT_Vector3 dir(act->m_refDirection);
 	MT_Scalar len = dir.length();
 	if (MT_fuzzyZero(len)) {
-		PyErr_SetString(PyExc_ValueError, "Invalid direction");
+		PyErr_SetString(PyExc_ValueError, "actuator.direction = vec: KX_ConstraintActuator, invalid direction");
 		return 1;
 	}
 	act->m_refDirVector = dir/len;
diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp
index 9fe7ab75267..af1dc7f67b2 100644
--- a/source/gameengine/Ketsji/KX_GameObject.cpp
+++ b/source/gameengine/Ketsji/KX_GameObject.cpp
@@ -1187,13 +1187,13 @@ PyObject* KX_GameObject::PyReplaceMesh(PyObject* value)
 
 	meshname = PyString_AsString(value);
 	if (meshname==NULL) {
-		PyErr_SetString(PyExc_ValueError, "Expected a mesh name");
+		PyErr_SetString(PyExc_ValueError, "gameOb.replaceMesh(value): KX_GameObject, expected a mesh name");
 		return NULL;
 	}
 	mesh_pt = SCA_ILogicBrick::m_sCurrentLogicManager->GetMeshByName(STR_String(meshname));
 	
 	if (mesh_pt==NULL) {
-		PyErr_SetString(PyExc_ValueError, "The mesh name given does not exist");
+		PyErr_SetString(PyExc_ValueError, "gameOb.replaceMesh(value): KX_GameObject, the mesh name given does not exist");
 		return NULL;
 	}
 	scene->ReplaceMesh(this, (class RAS_MeshObject*)mesh_pt);
@@ -1259,8 +1259,8 @@ PyObject *KX_GameObject::Map_GetItem(PyObject *self_v, PyObject *item)
 		return pyconvert;
 	}
 	else {
-		if(attr_str)	PyErr_Format(PyExc_KeyError, "KX_GameObject key \"%s\" does not exist", attr_str);
-		else			PyErr_SetString(PyExc_KeyError, "KX_GameObject key does not exist");
+		if(attr_str)	PyErr_Format(PyExc_KeyError, "value = gameOb[key]: KX_GameObject, key \"%s\" does not exist", attr_str);
+		else			PyErr_SetString(PyExc_KeyError, "value = gameOb[key]: KX_GameObject, key does not exist");
 		return NULL;
 	}
 		
@@ -1290,8 +1290,8 @@ int KX_GameObject::Map_SetItem(PyObject *self_v, PyObject *key, PyObject *val)
 			del |= (PyDict_DelItem(self->m_attr_dict, key)==0) ? 1:0;
 		
 		if (del==0) {
-			if(attr_str)	PyErr_Format(PyExc_KeyError, "KX_GameObject key \"%s\" not found", attr_str);
-			else			PyErr_SetString(PyExc_KeyError, "KX_GameObject key not found");
+			if(attr_str)	PyErr_Format(PyExc_KeyError, "gameOb[key] = value: KX_GameObject, key \"%s\" could not be set", attr_str);
+			else			PyErr_SetString(PyExc_KeyError, "gameOb[key] = value: KX_GameObject, key could not be set");
 			return -1;
 		}
 		else if (self->m_attr_dict) {
@@ -1342,8 +1342,8 @@ int KX_GameObject::Map_SetItem(PyObject *self_v, PyObject *key, PyObject *val)
 				set= 1;
 			}
 			else {
-				if(attr_str)	PyErr_Format(PyExc_KeyError, "KX_GameObject key \"%s\" not be added to internal dictionary", attr_str);
-				else			PyErr_SetString(PyExc_KeyError, "KX_GameObject key not be added to internal dictionary");
+				if(attr_str)	PyErr_Format(PyExc_KeyError, "gameOb[key] = value: KX_GameObject, key \"%s\" not be added to internal dictionary", attr_str);
+				else			PyErr_SetString(PyExc_KeyError, "gameOb[key] = value: KX_GameObject, key not be added to internal dictionary");
 			}
 		}
 		
@@ -1424,7 +1424,7 @@ int KX_GameObject::pyattr_set_mass(void *self_v, const KX_PYATTRIBUTE_DEF *attrd
 	KX_IPhysicsController *spc = self->GetPhysicsController();
 	MT_Scalar val = PyFloat_AsDouble(value);
 	if (val < 0.0f) { /* also accounts for non float */
-		PyErr_SetString(PyExc_AttributeError, "expected a float zero or above");
+		PyErr_SetString(PyExc_AttributeError, "gameOb.mass = float: KX_GameObject, expected a float zero or above");
 		return 1;
 	}
 
@@ -1447,7 +1447,7 @@ int KX_GameObject::pyattr_set_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF
 	KX_IPhysicsController *spc = self->GetPhysicsController();
 	MT_Scalar val = PyFloat_AsDouble(value);
 	if (val < 0.0f) { /* also accounts for non float */
-		PyErr_SetString(PyExc_AttributeError, "expected a float zero or above");
+		PyErr_SetString(PyExc_AttributeError, "gameOb.linVelocityMin = float: KX_GameObject, expected a float zero or above");
 		return 1;
 	}
 
@@ -1470,7 +1470,7 @@ int KX_GameObject::pyattr_set_lin_vel_max(void *self_v, const KX_PYATTRIBUTE_DEF
 	KX_IPhysicsController *spc = self->GetPhysicsController();
 	MT_Scalar val = PyFloat_AsDouble(value);
 	if (val < 0.0f) { /* also accounts for non float */
-		PyErr_SetString(PyExc_AttributeError, "expected a float zero or above");
+		PyErr_SetString(PyExc_AttributeError, "gameOb.linVelocityMax = float: KX_GameObject, expected a float zero or above");
 		return 1;
 	}
 
@@ -1492,7 +1492,7 @@ int KX_GameObject::pyattr_set_visible(void *self_v, const KX_PYATTRIBUTE_DEF *at
 	KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
 	int param = PyObject_IsTrue( value );
 	if (param == -1) {
-		PyErr_SetString(PyExc_AttributeError, "expected True or False");
+		PyErr_SetString(PyExc_AttributeError, "gameOb.visible = bool: KX_GameObject, expected True or False");
 		return 1;
 	}
 
@@ -1569,7 +1569,7 @@ int KX_GameObject::pyattr_set_localOrientation(void *self_v, const KX_PYATTRIBUT
 {
 	KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
 	if (!PySequence_Check(value)) {
-		PyErr_SetString(PyExc_AttributeError, "'orientation' attribute needs to be a sequence");
+		PyErr_SetString(PyExc_AttributeError, "gameOb.orientation = [...]: KX_GameObject, expected a sequence");
 		return 1;
 	}
 
@@ -1609,7 +1609,7 @@ int KX_GameObject::pyattr_set_localOrientation(void *self_v, const KX_PYATTRIBUT
 		return 1;
 	}
 
-	PyErr_SetString(PyExc_AttributeError, "could not set the orientation from a 3x3 matrix, quaternion or euler sequence");
+	PyErr_SetString(PyExc_AttributeError, "gameOb.orientation = [...]: KX_GameObject, could not set the orientation from a 3x3 matrix, quaternion or euler sequence");
 	return 1;
 }
 
@@ -1658,7 +1658,7 @@ int KX_GameObject::pyattr_set_timeOffset(void *self_v, const KX_PYATTRIBUTE_DEF
 		MT_Scalar val = PyFloat_AsDouble(value);
 		SG_Node* sg_parent= self->GetSGNode()->GetSGParent();
 		if (val < 0.0f) { /* also accounts for non float */
-			PyErr_SetString(PyExc_AttributeError, "expected a float zero or above");
+			PyErr_SetString(PyExc_AttributeError, "gameOb.timeOffset = float: KX_GameObject, expected a float zero or above");
 			return 1;
 		}
 		if (sg_parent && sg_parent->IsSlowParent())
@@ -1682,13 +1682,13 @@ int KX_GameObject::pyattr_set_state(void *self_v, const KX_PYATTRIBUTE_DEF *attr
 	unsigned int state = 0;
 	
 	if (state_i == -1 && PyErr_Occurred()) {
-		PyErr_SetString(PyExc_TypeError, "expected an int bit field");
+		PyErr_SetString(PyExc_TypeError, "gameOb.state = int: KX_GameObject, expected an int bit field");
 		return 1;
 	}
 	
 	state |= state_i;
 	if ((state & ((1<<30)-1)) == 0) {
-		PyErr_SetString(PyExc_AttributeError, "The state bitfield was not between 0 and 30 (1<<0 and 1<<29)");
+		PyErr_SetString(PyExc_AttributeError, "gameOb.state = int: KX_GameObject, state bitfield was not between 0 and 30 (1<<0 and 1<<29)");
 		return 1;
 	}
 	self->SetState(state);
@@ -1701,7 +1701,7 @@ PyObject* KX_GameObject::pyattr_get_meshes(void *self_v, const KX_PYATTRIBUTE_DE
 	PyObject *meshes= PyList_New(self->m_meshes.size());
 	int i;
 	
-	for(i=0; i < (int)self->m_meshes.size(); i++)
+	for(i=0; i < self->m_meshes.size(); i++)
 	{
 		KX_MeshProxy* meshproxy = new KX_MeshProxy(self->m_meshes[i]);
 		PyList_SET_ITEM(meshes, i, meshproxy->GetProxy());
@@ -1847,7 +1847,7 @@ int KX_GameObject::py_setattro(PyObject *attr, PyObject *value)	// py_setattro m
 			ret= PY_SET_ATTR_SUCCESS;
 		}
 		else {
-			PyErr_Format(PyExc_AttributeError, "failed assigning value to KX_GameObject internal dictionary");
+			PyErr_Format(PyExc_AttributeError, "gameOb.myAttr = value: KX_GameObject, failed assigning value to internal dictionary");
 			ret= PY_SET_ATTR_FAIL;
 		}
 	}
@@ -1866,7 +1866,7 @@ int	KX_GameObject::py_delattro(PyObject *attr)
 	if (m_attr_dict && (PyDict_DelItem(m_attr_dict, attr) == 0))
 		return 0;
 	
-	PyErr_Format(PyExc_AttributeError, "attribute \"%s\" dosnt exist", attr_str);
+	PyErr_Format(PyExc_AttributeError, "del gameOb.myAttr: KX_GameObject, attribute \"%s\" dosnt exist", attr_str);
 	return 1;
 }
 
@@ -2390,7 +2390,7 @@ KX_PYMETHODDEF_DOC_O(KX_GameObject, getVectTo,
 			toPoint = other->NodeGetWorldPosition();
 		} else
 		{
-			PyErr_SetString(PyExc_TypeError, "Expected a 3D Vector or GameObject type");
+			PyErr_SetString(PyExc_TypeError, "gameOb.getVectTo(other): KX_GameObject, expected a 3D Vector or KX_GameObject type");
 			return NULL;
 		}
 	}
@@ -2484,7 +2484,7 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCastTo,
 			toPoint = other->NodeGetWorldPosition();
 		} else
 		{
-			PyErr_SetString(PyExc_TypeError, "the first argument to rayCastTo must be a vector or a KX_GameObject");
+			PyErr_SetString(PyExc_TypeError, "gameOb.rayCastTo(other,dist,prop): KX_GameObject, the first argument to rayCastTo must be a vector or a KX_GameObject");
 			return NULL;
 		}
 	}
@@ -2577,7 +2577,7 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,
 			fromPoint = other->NodeGetWorldPosition();
 		} else
 		{
-			PyErr_SetString(PyExc_TypeError, "the second optional argument to rayCast must be a vector or a KX_GameObject");
+			PyErr_SetString(PyExc_TypeError, "gameOb.rayCast(to,from,dist,prop,face,xray,poly): KX_GameObject, the second optional argument to rayCast must be a vector or a KX_GameObject");
 			return NULL;
 		}
 	}
diff --git a/source/gameengine/Ketsji/KX_MeshProxy.cpp b/source/gameengine/Ketsji/KX_MeshProxy.cpp
index ded862fb21d..e2c59ab4242 100644
--- a/source/gameengine/Ketsji/KX_MeshProxy.cpp
+++ b/source/gameengine/Ketsji/KX_MeshProxy.cpp
@@ -243,7 +243,7 @@ PyObject* KX_MeshProxy::PyGetPolygon(PyObject* args, PyObject* kwds)
 	
 	if (polyindex<0 || polyindex >= m_meshobj->NumPolygons())
 	{
-		PyErr_SetString(PyExc_AttributeError, "Invalid polygon index");
+		PyErr_SetString(PyExc_AttributeError, "mesh.getPolygon(int): KX_MeshProxy, invalid polygon index");
 		return NULL;
 	}
 		
@@ -254,7 +254,7 @@ PyObject* KX_MeshProxy::PyGetPolygon(PyObject* args, PyObject* kwds)
 		polyob = (new KX_PolyProxy(m_meshobj, polygon))->NewProxy(true);
 	}
 	else {
-		PyErr_SetString(PyExc_AttributeError, "polygon is NULL, unknown reason");
+		PyErr_SetString(PyExc_AttributeError, "mesh.getPolygon(int): KX_MeshProxy, polygon is NULL, unknown reason");
 	}
 	return polyob;
 }
diff --git a/source/gameengine/Ketsji/KX_PolyProxy.cpp b/source/gameengine/Ketsji/KX_PolyProxy.cpp
index 5888579431a..2e5dd72db0e 100644
--- a/source/gameengine/Ketsji/KX_PolyProxy.cpp
+++ b/source/gameengine/Ketsji/KX_PolyProxy.cpp
@@ -242,7 +242,7 @@ KX_PYMETHODDEF_DOC(KX_PolyProxy, getVertexIndex,
 	}
 	if (index < 0 || index > 3)
 	{
-		PyErr_SetString(PyExc_AttributeError, "Valid range for index is 0-3");
+		PyErr_SetString(PyExc_AttributeError, "poly.getVertexIndex(int): KX_PolyProxy, expected an index between 0-3");
 		return NULL;
 	}
 	if (index < m_polygon->VertexCount())
diff --git a/source/gameengine/Ketsji/KX_PyMath.h b/source/gameengine/Ketsji/KX_PyMath.h
index 39c9c358792..4a64063aaa1 100644
--- a/source/gameengine/Ketsji/KX_PyMath.h
+++ b/source/gameengine/Ketsji/KX_PyMath.h
@@ -92,18 +92,35 @@ bool PyMatTo(PyObject* pymat, T& mat)
 }
 
 /**
- *  Converts a python list to a MT class.
+ *  Converts a python sequence to a MT class.
  */
 template<class T>
 bool PyVecTo(PyObject* pyval, T& vec)
 {
-	if (PySequence_Check(pyval))
+
+	if(PyTuple_Check(pyval))
+	{
+		unsigned int numitems = PyTuple_GET_SIZE(pyval);
+		if (numitems != Size(vec)) {
+			PyErr_Format(PyExc_AttributeError, "error setting vector, %d args, should be %d", numitems, Size(vec));
+			return false;
+		}
+		
+		for (unsigned int x = 0; x < numitems; x++)
+			vec[x] = PyFloat_AsDouble(PyTuple_GET_ITEM(pyval, x)); /* borrow ref */
+		
+		if (PyErr_Occurred()) {
+			PyErr_SetString(PyExc_AttributeError, "one or more of the items in the sequence was not a float");
+			return false;
+		}
+		
+		return true;
+	}
+	else if (PySequence_Check(pyval))
 	{
 		unsigned int numitems = PySequence_Size(pyval);
 		if (numitems != Size(vec)) {
-			char err[128];
-			sprintf(err, "error setting vector, %d args, should be %d", numitems, Size(vec));
-			PyErr_SetString(PyExc_AttributeError, err);
+			PyErr_Format(PyExc_AttributeError, "error setting vector, %d args, should be %d", numitems, Size(vec));
 			return false;
 		}
 		
@@ -122,9 +139,7 @@ bool PyVecTo(PyObject* pyval, T& vec)
 		return true;
 	} else
 	{
-		char err[128];
-		sprintf(err, "not a sequence type, expected a sequence of numbers size %d", Size(vec));
-		PyErr_SetString(PyExc_AttributeError, err);
+		PyErr_Format(PyExc_AttributeError, "not a sequence type, expected a sequence of numbers size %d", Size(vec));
 	}
 	
 	return false;
diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index 2227072d2e7..097d20fe0e5 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -553,7 +553,7 @@ static PyObject* gPySetEyeSeparation(PyObject*, PyObject* args)
 		return NULL;
 
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setEyeSeparation(float), Rasterizer not available");
 		return NULL;
 	}
 	
@@ -565,7 +565,7 @@ static PyObject* gPySetEyeSeparation(PyObject*, PyObject* args)
 static PyObject* gPyGetEyeSeparation(PyObject*)
 {
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.getEyeSeparation(), Rasterizer not available");
 		return NULL;
 	}
 	
@@ -579,7 +579,7 @@ static PyObject* gPySetFocalLength(PyObject*, PyObject* args)
 		return NULL;
 	
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setFocalLength(float), Rasterizer not available");
 		return NULL;
 	}
 
@@ -591,7 +591,7 @@ static PyObject* gPySetFocalLength(PyObject*, PyObject* args)
 static PyObject* gPyGetFocalLength(PyObject*, PyObject*, PyObject*)
 {
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.getFocalLength(), Rasterizer not available");
 		return NULL;
 	}
 	
@@ -624,7 +624,7 @@ static PyObject* gPySetMistColor(PyObject*, PyObject* value)
 		return NULL;
 	
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setMistColor(color), Rasterizer not available");
 		return NULL;
 	}	
 	gp_Rasterizer->SetFogColor(vec[0], vec[1], vec[2]);
@@ -642,7 +642,7 @@ static PyObject* gPySetMistStart(PyObject*, PyObject* args)
 		return NULL;
 	
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setMistStart(float), Rasterizer not available");
 		return NULL;
 	}
 	
@@ -661,7 +661,7 @@ static PyObject* gPySetMistEnd(PyObject*, PyObject* args)
 		return NULL;
 	
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setMistEnd(float), Rasterizer not available");
 		return NULL;
 	}
 	
@@ -679,7 +679,7 @@ static PyObject* gPySetAmbientColor(PyObject*, PyObject* value)
 		return NULL;
 	
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setAmbientColor(color), Rasterizer not available");
 		return NULL;
 	}	
 	gp_Rasterizer->SetAmbientColor(vec[0], vec[1], vec[2]);
@@ -711,7 +711,7 @@ static PyObject* gPyEnableMotionBlur(PyObject*, PyObject* args)
 		return NULL;
 	
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.enableMotionBlur(float), Rasterizer not available");
 		return NULL;
 	}
 	
@@ -723,7 +723,7 @@ static PyObject* gPyEnableMotionBlur(PyObject*, PyObject* args)
 static PyObject* gPyDisableMotionBlur(PyObject*, PyObject* args)
 {
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.disableMotionBlur(), Rasterizer not available");
 		return NULL;
 	}
 	
@@ -763,7 +763,7 @@ static PyObject* gPySetGLSLMaterialSetting(PyObject*,
 	flag = getGLSLSettingFlag(setting);
 	
 	if  (flag==-1) {
-		PyErr_SetString(PyExc_ValueError, "glsl setting is not known");
+		PyErr_SetString(PyExc_ValueError, "Rasterizer.setGLSLMaterialSetting(string): glsl setting is not known");
 		return NULL;
 	}
 
@@ -804,7 +804,7 @@ static PyObject* gPyGetGLSLMaterialSetting(PyObject*,
 	flag = getGLSLSettingFlag(setting);
 	
 	if  (flag==-1) {
-		PyErr_SetString(PyExc_ValueError, "glsl setting is not known");
+		PyErr_SetString(PyExc_ValueError, "Rasterizer.getGLSLMaterialSetting(string): glsl setting is not known");
 		return NULL;
 	}
 
@@ -832,7 +832,7 @@ static PyObject* gPySetMaterialType(PyObject*,
 	else if(type == KX_TEXFACE_MATERIAL)
 		flag = 0;
 	else {
-		PyErr_SetString(PyExc_ValueError, "material type is not known");
+		PyErr_SetString(PyExc_ValueError, "Rasterizer.setMaterialType(int): material type is not known");
 		return NULL;
 	}
 
@@ -863,7 +863,7 @@ static PyObject* gPyDrawLine(PyObject*, PyObject* args)
 	PyObject* ob_color;
 
 	if (!gp_Rasterizer) {
-		PyErr_SetString(PyExc_RuntimeError, "Rasterizer not available");
+		PyErr_SetString(PyExc_RuntimeError, "Rasterizer.drawLine(obFrom, obTo, color): Rasterizer not available");
 		return NULL;
 	}
 
@@ -1270,7 +1270,7 @@ PyObject *KXpy_reload(PyObject *self, PyObject *args) {
 		return newmodule;
 	
 	if (found==0) /* if its found but could not import then it has its own error */
-		PyErr_SetString(PyExc_ImportError, "failed to reload from blenders internal text");
+		PyErr_SetString(PyExc_ImportError, "reload(module): failed to reload from blenders internal text");
 	
 	return newmodule;
 }
@@ -1517,7 +1517,7 @@ static PyObject* gPyEventToString(PyObject*, PyObject* value)
 	
 	PyErr_Clear(); // incase there was an error clearing
 	Py_DECREF(mod);
-	if (!ret)	PyErr_SetString(PyExc_ValueError, "expected a valid int keyboard event");
+	if (!ret)	PyErr_SetString(PyExc_ValueError, "GameKeys.EventToString(int): expected a valid int keyboard event");
 	else		Py_INCREF(ret);
 	
 	return ret;
diff --git a/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp b/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp
index 44dedb38429..53067e94cd8 100644
--- a/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp
@@ -121,7 +121,7 @@ int KX_SCA_ReplaceMeshActuator::pyattr_set_mesh(void *self, const struct KX_PYAT
 	} else if (PyString_Check(value)) {
 		void* mesh = SCA_ILogicBrick::m_sCurrentLogicManager->GetMeshByName(STR_String(PyString_AsString(value)));
 		if (mesh==NULL) {
-			PyErr_SetString(PyExc_ValueError, "The mesh name given does not exist");
+			PyErr_SetString(PyExc_ValueError, "actuator.mesh = string: Replace Mesh Actuator, mesh name given does not exist");
 			return 1;
 		}
 		actuator->m_mesh= (class RAS_MeshObject*)mesh;
@@ -129,7 +129,7 @@ int KX_SCA_ReplaceMeshActuator::pyattr_set_mesh(void *self, const struct KX_PYAT
 		KX_MeshProxy* proxy = (KX_MeshProxy*)value;
 		actuator->m_mesh= proxy->GetMesh();
 	} else {
-		PyErr_SetString(PyExc_ValueError, "Expected the name of a mesh, a mesh proxy or None");
+		PyErr_SetString(PyExc_ValueError, "actuator.mesh = value: Replace Mesh Actuator, expected the mesh name, a KX_MeshProxy or None");
 		return 1;
 	}
 	return 0;
diff --git a/source/gameengine/Ketsji/KX_Scene.cpp b/source/gameengine/Ketsji/KX_Scene.cpp
index 96f2f3e8ed3..0e1572da679 100644
--- a/source/gameengine/Ketsji/KX_Scene.cpp
+++ b/source/gameengine/Ketsji/KX_Scene.cpp
@@ -1678,7 +1678,7 @@ PyObject* KX_Scene::py_getattro(PyObject *attr)
 			Py_INCREF(object);
 		}
 		else {
-			PyErr_Format(PyExc_AttributeError, "KX_Scene attribute \"%s\" not found", PyString_AsString(attr));
+			PyErr_Format(PyExc_AttributeError, "value = scene.myAttr: KX_Scene, attribute \"%s\" not found", PyString_AsString(attr));
 		}
 	}
 	
@@ -1696,7 +1696,7 @@ int KX_Scene::py_setattro(PyObject *attr, PyObject *value)
 			ret= PY_SET_ATTR_SUCCESS;
 		}
 		else {
-			PyErr_SetString(PyExc_AttributeError, "failed assigning value to KX_Scenes internal dictionary");
+			PyErr_SetString(PyExc_AttributeError, "scene.UserAttr = value: KX_Scenes, failed assigning value to internal dictionary");
 			ret= PY_SET_ATTR_FAIL;
 		}
 	}
diff --git a/source/gameengine/Ketsji/KX_SoundActuator.cpp b/source/gameengine/Ketsji/KX_SoundActuator.cpp
index eb1d91d760f..b9edd7436df 100644
--- a/source/gameengine/Ketsji/KX_SoundActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SoundActuator.cpp
@@ -355,7 +355,7 @@ PyObject* KX_SoundActuator::pyattr_get_filename(void *self, const struct KX_PYAT
 	char* name = objectname.Ptr();
 	
 	if (!name) {
-		PyErr_SetString(PyExc_RuntimeError, "Unable to get sound filename");
+		PyErr_SetString(PyExc_RuntimeError, "value = actuator.filename: KX_SoundActuator, unable to get sound filename");
 		return NULL;
 	} else
 		return PyString_FromString(name);
@@ -541,7 +541,7 @@ int KX_SoundActuator::pyattr_set_orientation(void *self, const struct KX_PYATTRI
 	KX_SoundActuator * actuator = static_cast<KX_SoundActuator *> (self);
 
 	if (!PySequence_Check(value)) {
-		PyErr_SetString(PyExc_AttributeError, "'orientation' attribute needs to be a sequence");
+		PyErr_SetString(PyExc_AttributeError, "value = actuator.orientation: KX_SoundActuator, expected a sequence");
 		return 1;
 	}
 
diff --git a/source/gameengine/Ketsji/KX_TouchSensor.cpp b/source/gameengine/Ketsji/KX_TouchSensor.cpp
index e7f8acbd1a8..5a6e8e6f501 100644
--- a/source/gameengine/Ketsji/KX_TouchSensor.cpp
+++ b/source/gameengine/Ketsji/KX_TouchSensor.cpp
@@ -369,7 +369,7 @@ const char KX_TouchSensor::GetTouchMaterial_doc[] =
 "\tKX_FALSE if it looks for a specific property.\n" ;
 PyObject* KX_TouchSensor::PyGetTouchMaterial()
 {
-	ShowDeprecationWarning("getTouchMaterial()", "the materialCheck property");
+	ShowDeprecationWarning("getTouchMaterial()", "the useMaterial property");
 	return PyInt_FromLong(m_bFindMaterial);
 }
 
@@ -382,6 +382,7 @@ const char KX_TouchSensor::SetTouchMaterial_doc[] =
 "\tKX_FALSE to switch off positive pulse mode.\n" ;
 PyObject* KX_TouchSensor::PySetTouchMaterial(PyObject *value)
 {
+	ShowDeprecationWarning("setTouchMaterial()", "the useMaterial property");
 	int pulseArg = PyInt_AsLong(value);
 
 	if(pulseArg ==-1 && PyErr_Occurred()) {
diff --git a/source/gameengine/Ketsji/KX_VertexProxy.cpp b/source/gameengine/Ketsji/KX_VertexProxy.cpp
index 8be125011bb..88f63334285 100644
--- a/source/gameengine/Ketsji/KX_VertexProxy.cpp
+++ b/source/gameengine/Ketsji/KX_VertexProxy.cpp
@@ -398,7 +398,7 @@ PyObject* KX_VertexProxy::PySetRGBA(PyObject* value)
 		}
 	}
 	
-	PyErr_SetString(PyExc_TypeError, "expected a 4D vector or an int");
+	PyErr_SetString(PyExc_TypeError, "vert.setRGBA(value): KX_VertexProxy, expected a 4D vector or an int");
 	return NULL;
 }