BGE Python API

Use 'const char *' rather then the C++ 'STR_String' type for the attribute identifier of python attributes.

Each attribute and method access from python was allocating and freeing the string.
A simple test with getting an attribute a loop shows this speeds up attribute lookups a bit over 2x.

source/gameengine/Converter/BL_ActionActuator.cpp

@@ -1035,8 +1035,8 @@ PyAttributeDef BL_ActionActuator::Attributes[] = {
 	{ NULL }	//Sentinel
 };
 
-PyObject* BL_ActionActuator::_getattr(const STR_String& attr) {
-	if (attr == "action")
+PyObject* BL_ActionActuator::_getattr(const char *attr) {
+	if (!strcmp(attr, "action"))
 		return PyString_FromString(m_action->id.name+2);
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
@@ -1044,8 +1044,8 @@ PyObject* BL_ActionActuator::_getattr(const STR_String& attr) {
 	_getattr_up(SCA_IActuator);
 }
 
-int BL_ActionActuator::_setattr(const STR_String& attr, PyObject* value) {
-	if (attr == "action")
+int BL_ActionActuator::_setattr(const char *attr, PyObject* value) {
+	if (!strcmp(attr, "action"))
 	{
 		if (!PyString_Check(value))
 		{

source/gameengine/Converter/BL_ActionActuator.h

@@ -110,8 +110,8 @@ public:
 
 	KX_PYMETHOD_DOC(BL_ActionActuator,setChannel);
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject* value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject* value);
 
 	/* attribute check */
 	static int CheckFrame(void *self, const PyAttributeDef*)

source/gameengine/Converter/BL_BlenderDataConversion.cpp

@@ -361,7 +361,7 @@ BL_Material* ConvertMaterial(
 			facetex = true;
 		if(validface && mat->mtex[0]) {
 			MTex *tmp = mat->mtex[0];
-			if(!tmp->tex || tmp->tex && !tmp->tex->ima )
+			if(!tmp->tex || (tmp->tex && !tmp->tex->ima))
 				facetex = true;
 		}
 		numchan = numchan>MAXTEX?MAXTEX:numchan;

source/gameengine/Converter/BL_ShapeActionActuator.cpp

@@ -484,8 +484,8 @@ PyAttributeDef BL_ShapeActionActuator::Attributes[] = {
 };
 
 
-PyObject* BL_ShapeActionActuator::_getattr(const STR_String& attr) {
-	if (attr == "action")
+PyObject* BL_ShapeActionActuator::_getattr(const char *attr) {
+	if (!strcmp(attr, "action"))
 		return PyString_FromString(m_action->id.name+2);
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
@@ -493,8 +493,8 @@ PyObject* BL_ShapeActionActuator::_getattr(const STR_String& attr) {
 	_getattr_up(SCA_IActuator);
 }
 
-int BL_ShapeActionActuator::_setattr(const STR_String& attr, PyObject* value) {
-	if (attr == "action")
+int BL_ShapeActionActuator::_setattr(const char *attr, PyObject* value) {
+	if (!strcmp(attr, "action"))
 	{
 		if (!PyString_Check(value))
 		{

source/gameengine/Converter/BL_ShapeActionActuator.h

@@ -103,8 +103,8 @@ public:
 	KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetType);
 	KX_PYMETHOD_DOC(BL_ShapeActionActuator,SetType);
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject* value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject* value);
 
 	static int CheckBlendTime(void *self, const PyAttributeDef*)
 	{

source/gameengine/Expressions/ListValue.cpp

@@ -234,7 +234,7 @@ PyMethodDef CListValue::Methods[] = {
 
 
 
-PyObject* CListValue::_getattr(const STR_String& attr) {
+PyObject* CListValue::_getattr(const char *attr) {
 	_getattr_up(CValue);
 }
 

source/gameengine/Expressions/ListValue.h

@@ -59,7 +59,7 @@ public:
 
 	bool CheckEqual(CValue* first,CValue* second);
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	KX_PYMETHOD(CListValue,append);
 	KX_PYMETHOD(CListValue,reverse);

source/gameengine/Expressions/PyObjectPlus.cpp

@@ -106,24 +106,24 @@ PyParentObject PyObjectPlus::Parents[] = {&PyObjectPlus::Type, NULL};
 /*------------------------------
  * PyObjectPlus attributes	-- attributes
 ------------------------------*/
-PyObject *PyObjectPlus::_getattr(const STR_String& attr)
+PyObject *PyObjectPlus::_getattr(const char *attr)
 {
-	if (attr == "__doc__" && GetType()->tp_doc)
+	if (!strcmp(attr, "__doc__") && GetType()->tp_doc)
 		return PyString_FromString(GetType()->tp_doc);
 
   //if (streq(attr, "type"))
   //  return Py_BuildValue("s", (*(GetParents()))->tp_name);
 
-  return Py_FindMethod(Methods, this, const_cast<char *>(attr.ReadPtr()));
+  return Py_FindMethod(Methods, this, attr);
 }
 
-int PyObjectPlus::_delattr(const STR_String& attr)
+int PyObjectPlus::_delattr(const char *attr)
 {
 	PyErr_SetString(PyExc_AttributeError, "attribute cant be deleted");
 	return 1;
 }
 
-int PyObjectPlus::_setattr(const STR_String& attr, PyObject *value)
+int PyObjectPlus::_setattr(const char *attr, PyObject *value)
 {
 	//return PyObject::_setattr(attr,value);
 	//cerr << "Unknown attribute" << endl;
@@ -131,12 +131,12 @@ int PyObjectPlus::_setattr(const STR_String& attr, PyObject *value)
 	return 1;
 }
 
-PyObject *PyObjectPlus::_getattr_self(const PyAttributeDef attrlist[], void *self, const STR_String &attr)
+PyObject *PyObjectPlus::_getattr_self(const PyAttributeDef attrlist[], void *self, const char *attr)
 {
 	const PyAttributeDef *attrdef;
 	for (attrdef=attrlist; attrdef->m_name != NULL; attrdef++)
 	{
-		if (attr == attrdef->m_name) 
+		if (!strcmp(attr, attrdef->m_name))
 		{
 			if (attrdef->m_type == KX_PYATTRIBUTE_TYPE_DUMMY)
 			{
@@ -238,7 +238,7 @@ PyObject *PyObjectPlus::_getattr_self(const PyAttributeDef attrlist[], void *sel
 	return NULL;
 }
 
-int PyObjectPlus::_setattr_self(const PyAttributeDef attrlist[], void *self, const STR_String &attr, PyObject *value)
+int PyObjectPlus::_setattr_self(const PyAttributeDef attrlist[], void *self, const char *attr, PyObject *value)
 {
 	const PyAttributeDef *attrdef;
 	void *undoBuffer = NULL;
@@ -247,7 +247,7 @@ int PyObjectPlus::_setattr_self(const PyAttributeDef attrlist[], void *self, con
 
 	for (attrdef=attrlist; attrdef->m_name != NULL; attrdef++)
 	{
-		if (attr == attrdef->m_name) 
+		if (!strcmp(attr, attrdef->m_name))
 		{
 			if (attrdef->m_access == KX_PYATTRIBUTE_RO ||
 				attrdef->m_type == KX_PYATTRIBUTE_TYPE_DUMMY)

source/gameengine/Expressions/PyObjectPlus.h

@@ -97,7 +97,7 @@ static inline void Py_Fatal(const char *M) {
 								// to be properly passed up the hierarchy.
 #define _getattr_up(Parent) \
   PyObject *rvalue = NULL; \
-  if (attr=="__methods__") { \
+  if (!strcmp(attr, "__methods__")) { \
     PyObject *_attr_string = NULL; \
     PyMethodDef *meth = Methods; \
     rvalue = Parent::_getattr(attr); \
@@ -113,7 +113,7 @@ static inline void Py_Fatal(const char *M) {
 	  } \
 	} \
   } else { \
-    rvalue = Py_FindMethod(Methods, this, const_cast<char*>(attr.ReadPtr())); \
+    rvalue = Py_FindMethod(Methods, this, attr); \
     if (rvalue == NULL) { \
       PyErr_Clear(); \
       rvalue = Parent::_getattr(attr); \
@@ -348,23 +348,23 @@ public:
 //		  Py_DECREF(this);
 //	  };				// decref method
 	
-	virtual PyObject *_getattr(const STR_String& attr);			// _getattr method
+	virtual PyObject *_getattr(const char *attr);			// _getattr method
 	static  PyObject *__getattr(PyObject * PyObj, char *attr) 	// This should be the entry in Type. 
 	{
-		return ((PyObjectPlus*) PyObj)->_getattr(STR_String(attr)); 
+		return ((PyObjectPlus*) PyObj)->_getattr(attr); 
 	}
-	static PyObject *_getattr_self(const PyAttributeDef attrlist[], void *self, const STR_String &attr);
-	static int _setattr_self(const PyAttributeDef attrlist[], void *self, const STR_String &attr, PyObject *value);
+	static PyObject *_getattr_self(const PyAttributeDef attrlist[], void *self, const char *attr);
+	static int _setattr_self(const PyAttributeDef attrlist[], void *self, const char *attr, PyObject *value);
 	
-	virtual int _delattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);		// _setattr method
+	virtual int _delattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);		// _setattr method
 	static  int __setattr(PyObject *PyObj, 			// This should be the entry in Type. 
 				char *attr, 
 				PyObject *value)
 	{ 
 		if (!value)
 			return ((PyObjectPlus*) PyObj)->_delattr(attr);
-		return ((PyObjectPlus*) PyObj)->_setattr(STR_String(attr), value);  
+		return ((PyObjectPlus*) PyObj)->_setattr(attr, value);  
 	}
 	
 	virtual PyObject *_repr(void);				// _repr method

source/gameengine/Expressions/Value.cpp

@@ -674,9 +674,9 @@ static PyMethodDef	CValueMethods[] =
 };
 
 
-PyObject*	CValue::_getattr(const STR_String& attr)
+PyObject*	CValue::_getattr(const char *attr)
 {
-	CValue* resultattr = FindIdentifier(attr);
+	CValue* resultattr = FindIdentifier(STR_String(attr));
 	STR_String text;
 	if (resultattr)
 	{
@@ -761,26 +761,27 @@ CValue* CValue::ConvertPythonToValue(PyObject* pyobj)
 
 }
 
-int	CValue::_delattr(const STR_String& attr)
+int	CValue::_delattr(const char *attr)
 {
-	if (!RemoveProperty(attr)) /* sets error */
+	if (!RemoveProperty(STR_String(attr))) /* sets error */
 		return 1;
 	return 0;
 }
 
-int	CValue::_setattr(const STR_String& attr,PyObject* pyobj)
+int	CValue::_setattr(const char *attr,PyObject* pyobj)
 {
 	CValue* vallie = ConvertPythonToValue(pyobj);
 	if (vallie)
 	{
-		CValue* oldprop = GetProperty(attr);
+		STR_String attr_str = attr;
+		CValue* oldprop = GetProperty(attr_str);
 		
 		if (oldprop)
 		{
 			oldprop->SetValue(vallie);
 		} else
 		{
-			SetProperty(attr,vallie);
+			SetProperty(attr_str, vallie);
 		}
 		vallie->Release();
 	} else

source/gameengine/Expressions/Value.h

@@ -223,7 +223,7 @@ public:
 
 
 
-	virtual PyObject*			_getattr(const STR_String& attr);
+	virtual PyObject*			_getattr(const char *attr);
 
 	void	SpecialRelease()
 	{
@@ -250,8 +250,8 @@ public:
 	virtual CValue*	ConvertPythonToValue(PyObject* pyobj);
 
 
-	virtual int				_delattr(const STR_String& attr);
-	virtual int				_setattr(const STR_String& attr,PyObject* value);
+	virtual int				_delattr(const char *attr);
+	virtual int				_setattr(const char *attr, PyObject* value);
 	
 	virtual PyObject* ConvertKeysToPython( void );
 	

source/gameengine/GameLogic/SCA_2DFilterActuator.cpp

@@ -114,6 +114,6 @@ PyMethodDef SCA_2DFilterActuator::Methods[] = {
 };
 
 
-PyObject* SCA_2DFilterActuator::_getattr(const STR_String& attr) {
+PyObject* SCA_2DFilterActuator::_getattr(const char *attr) {
     _getattr_up(SCA_IActuator);
 }

source/gameengine/GameLogic/SCA_2DFilterActuator.h

@@ -38,7 +38,7 @@ public:
     virtual bool Update();
 
     virtual CValue* GetReplica();
-    virtual PyObject* _getattr(const STR_String& attr);
+    virtual PyObject* _getattr(const char *attr);
 
 };
 #endif

source/gameengine/GameLogic/SCA_ANDController.cpp

@@ -137,7 +137,7 @@ PyMethodDef SCA_ANDController::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* SCA_ANDController::_getattr(const STR_String& attr) {
+PyObject* SCA_ANDController::_getattr(const char *attr) {
 	_getattr_up(SCA_IController);
 }
 

source/gameengine/GameLogic/SCA_ANDController.h

@@ -48,7 +48,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 };
 

source/gameengine/GameLogic/SCA_ActuatorSensor.cpp

@@ -161,7 +161,7 @@ PyAttributeDef SCA_ActuatorSensor::Attributes[] = {
 	{ NULL }	//Sentinel
 };
 
-PyObject* SCA_ActuatorSensor::_getattr(const STR_String& attr) {
+PyObject* SCA_ActuatorSensor::_getattr(const char *attr) {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
 		return object;
@@ -180,7 +180,7 @@ int SCA_ActuatorSensor::CheckActuator(void *self, const PyAttributeDef*)
 	return 1;
 }
 
-int SCA_ActuatorSensor::_setattr(const STR_String& attr, PyObject *value) {
+int SCA_ActuatorSensor::_setattr(const char *attr, PyObject *value) {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)
 		return ret;

source/gameengine/GameLogic/SCA_ActuatorSensor.h

@@ -61,8 +61,8 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	/* 3. setProperty */
 	KX_PYMETHOD_DOC(SCA_ActuatorSensor,SetActuator);

source/gameengine/GameLogic/SCA_AlwaysSensor.cpp

@@ -135,7 +135,7 @@ PyMethodDef SCA_AlwaysSensor::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* SCA_AlwaysSensor::_getattr(const STR_String& attr) {
+PyObject* SCA_AlwaysSensor::_getattr(const char *attr) {
 	_getattr_up(SCA_ISensor);
 }
 

source/gameengine/GameLogic/SCA_AlwaysSensor.h

@@ -52,7 +52,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 	
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	
 };

source/gameengine/GameLogic/SCA_DelaySensor.cpp

@@ -178,14 +178,14 @@ PyAttributeDef SCA_DelaySensor::Attributes[] = {
 	{ NULL }	//Sentinel
 };
 
-PyObject* SCA_DelaySensor::_getattr(const STR_String& attr) {
+PyObject* SCA_DelaySensor::_getattr(const char *attr) {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
 		return object;
 	_getattr_up(SCA_ISensor);
 }
 
-int SCA_DelaySensor::_setattr(const STR_String& attr, PyObject *value) {
+int SCA_DelaySensor::_setattr(const char *attr, PyObject *value) {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)
 		return ret;

source/gameengine/GameLogic/SCA_DelaySensor.h

@@ -60,8 +60,8 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 	
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	/* setProperty */
 	KX_PYMETHOD_DOC(SCA_DelaySensor,SetDelay);

source/gameengine/GameLogic/SCA_ExpressionController.h

@@ -53,7 +53,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-//	virtual PyObject* _getattr(const STR_String& attr);
+//	virtual PyObject* _getattr(const char *attr);
 
 };
 

source/gameengine/GameLogic/SCA_ILogicBrick.cpp

@@ -278,7 +278,7 @@ int SCA_ILogicBrick::CheckProperty(void *self, const PyAttributeDef *attrdef)
 }
 
 PyObject*
-SCA_ILogicBrick::_getattr(const STR_String& attr)
+SCA_ILogicBrick::_getattr(const char *attr)
 {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
@@ -286,7 +286,7 @@ SCA_ILogicBrick::_getattr(const STR_String& attr)
   _getattr_up(CValue);
 }
 
-int SCA_ILogicBrick::_setattr(const STR_String& attr, PyObject *value)
+int SCA_ILogicBrick::_setattr(const char *attr, PyObject *value)
 {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)

source/gameengine/GameLogic/SCA_ILogicBrick.h

@@ -78,8 +78,8 @@ public:
 
 	virtual	bool		LessComparedTo(SCA_ILogicBrick* other);
 	
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	static class SCA_LogicManager*	m_sCurrentLogicManager;
 

source/gameengine/GameLogic/SCA_IObject.cpp

@@ -409,7 +409,7 @@ PyMethodDef SCA_IObject::Methods[] = {
 
 
 
-PyObject* SCA_IObject::_getattr(const STR_String& attr) {
+PyObject* SCA_IObject::_getattr(const char *attr) {
 	_getattr_up(CValue);
 }
 

source/gameengine/GameLogic/SCA_IObject.h

@@ -145,7 +145,7 @@ public:
 //	const class MT_Point3&	ConvertPythonPylist(PyObject* pylist);
 	
 	// here come the python forwarded methods
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	virtual int GetGameObjectType() {return -1;}
 	

source/gameengine/GameLogic/SCA_ISensor.cpp

@@ -461,19 +461,19 @@ PyAttributeDef SCA_ISensor::Attributes[] = {
 };
 
 PyObject*
-SCA_ISensor::_getattr(const STR_String& attr)
+SCA_ISensor::_getattr(const char *attr)
 {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
 		return object;
-	if (attr == "triggered")
+	if (!strcmp(attr, "triggered"))
 	{
 		int retval = 0;
 		if (SCA_PythonController::m_sCurrentController)
 			retval = SCA_PythonController::m_sCurrentController->IsTriggered(this);
 		return PyInt_FromLong(retval);
 	}
-	if (attr == "positive")
+	if (!strcmp(attr, "positive"))
 	{	
 		int retval = IsPositiveTrigger();
 		return PyInt_FromLong(retval);
@@ -481,7 +481,7 @@ SCA_ISensor::_getattr(const STR_String& attr)
 	_getattr_up(SCA_ILogicBrick);
 }
 
-int SCA_ISensor::_setattr(const STR_String& attr, PyObject *value)
+int SCA_ISensor::_setattr(const char *attr, PyObject *value)
 {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)

source/gameengine/GameLogic/SCA_ISensor.h

@@ -141,8 +141,8 @@ public:
 
 	/* Python functions: */
 	
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	//Deprecated functions ----->
 	KX_PYMETHOD_DOC_NOARGS(SCA_ISensor,IsPositive);

source/gameengine/GameLogic/SCA_JoystickSensor.cpp

@@ -343,24 +343,24 @@ PyAttributeDef SCA_JoystickSensor::Attributes[] = {
 	{ NULL }	//Sentinel
 };
 
-PyObject* SCA_JoystickSensor::_getattr(const STR_String& attr) {
+PyObject* SCA_JoystickSensor::_getattr(const char *attr) {
 	SCA_Joystick *joy = m_pJoystickMgr->GetJoystickDevice(m_joyindex);
-	if (attr == "axisPosition") {
+	if (!strcmp(attr, "axisPosition")) {
 		if(joy)
 			return Py_BuildValue("[iiii]", joy->GetAxis10(), joy->GetAxis11(), joy->GetAxis20(), joy->GetAxis21());
 		else
 			return Py_BuildValue("[iiii]", 0, 0, 0, 0);
 	}
-	if (attr == "numAxis") {
+	if (!strcmp(attr, "numAxis")) {
 		return PyInt_FromLong( joy ? joy->GetNumberOfAxes() : 0 );
 	}
-	if (attr == "numButtons") {
+	if (!strcmp(attr, "numButtons")) {
 		return PyInt_FromLong( joy ? joy->GetNumberOfButtons() : 0 );
 	}
-	if (attr == "numHats") {
+	if (!strcmp(attr, "numHats")) {
 		return PyInt_FromLong( joy ? joy->GetNumberOfHats() : 0 );
 	}
-	if (attr == "connected") {
+	if (!strcmp(attr, "connected")) {
 		return PyBool_FromLong( joy ? joy->Connected() : 0 );
 	}
 	PyObject* object = _getattr_self(Attributes, this, attr);
@@ -369,7 +369,7 @@ PyObject* SCA_JoystickSensor::_getattr(const STR_String& attr) {
 	_getattr_up(SCA_ISensor);
 }
 
-int SCA_JoystickSensor::_setattr(const STR_String& attr, PyObject *value) 
+int SCA_JoystickSensor::_setattr(const char *attr, PyObject *value) 
 {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)

source/gameengine/GameLogic/SCA_JoystickSensor.h

@@ -121,8 +121,8 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	/* Joystick Index */
 	KX_PYMETHOD_DOC_NOARGS(SCA_JoystickSensor,GetIndex);

source/gameengine/GameLogic/SCA_KeyboardSensor.cpp

@@ -831,7 +831,7 @@ PyAttributeDef SCA_KeyboardSensor::Attributes[] = {
 };
 
 PyObject*
-SCA_KeyboardSensor::_getattr(const STR_String& attr)
+SCA_KeyboardSensor::_getattr(const char *attr)
 {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
@@ -839,7 +839,7 @@ SCA_KeyboardSensor::_getattr(const STR_String& attr)
   _getattr_up(SCA_ISensor);
 }
 
-int SCA_KeyboardSensor::_setattr(const STR_String& attr, PyObject *value)
+int SCA_KeyboardSensor::_setattr(const char *attr, PyObject *value)
 {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)

source/gameengine/GameLogic/SCA_KeyboardSensor.h

@@ -126,8 +126,8 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	//Deprecated functions ----->
 	/** 1. GetKey : check which key this sensor looks at */

source/gameengine/GameLogic/SCA_MouseSensor.cpp

@@ -341,7 +341,7 @@ PyAttributeDef SCA_MouseSensor::Attributes[] = {
 	{ NULL }	//Sentinel
 };
 
-PyObject* SCA_MouseSensor::_getattr(const STR_String& attr) 
+PyObject* SCA_MouseSensor::_getattr(const char *attr) 
 {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
@@ -349,7 +349,7 @@ PyObject* SCA_MouseSensor::_getattr(const STR_String& attr)
 	_getattr_up(SCA_ISensor);
 }
 
-int SCA_MouseSensor::_setattr(const STR_String& attr, PyObject *value)
+int SCA_MouseSensor::_setattr(const char *attr, PyObject *value)
 {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)

source/gameengine/GameLogic/SCA_MouseSensor.h

@@ -109,8 +109,8 @@ class SCA_MouseSensor : public SCA_ISensor
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	//Deprecated functions ----->
 	/* read x-coordinate */

source/gameengine/GameLogic/SCA_NANDController.cpp

@@ -137,7 +137,7 @@ PyMethodDef SCA_NANDController::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* SCA_NANDController::_getattr(const STR_String& attr) {
+PyObject* SCA_NANDController::_getattr(const char *attr) {
 	_getattr_up(SCA_IController);
 }
 

source/gameengine/GameLogic/SCA_NANDController.h

@@ -48,7 +48,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 };
 

source/gameengine/GameLogic/SCA_NORController.cpp

@@ -137,7 +137,7 @@ PyMethodDef SCA_NORController::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* SCA_NORController::_getattr(const STR_String& attr) {
+PyObject* SCA_NORController::_getattr(const char *attr) {
 	_getattr_up(SCA_IController);
 }
 

source/gameengine/GameLogic/SCA_NORController.h

@@ -48,7 +48,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 };
 

source/gameengine/GameLogic/SCA_ORController.cpp

@@ -129,7 +129,7 @@ PyMethodDef SCA_ORController::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* SCA_ORController::_getattr(const STR_String& attr) {
+PyObject* SCA_ORController::_getattr(const char *attr) {
 	_getattr_up(SCA_IController);
 }
 

source/gameengine/GameLogic/SCA_ORController.h

@@ -49,7 +49,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 };
 
 #endif //__KX_ORCONTROLLER

source/gameengine/GameLogic/SCA_PropertyActuator.cpp

@@ -260,14 +260,14 @@ PyAttributeDef SCA_PropertyActuator::Attributes[] = {
 	{ NULL }	//Sentinel
 };
 
-PyObject* SCA_PropertyActuator::_getattr(const STR_String& attr) {
+PyObject* SCA_PropertyActuator::_getattr(const char *attr) {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
 		return object;
 	_getattr_up(SCA_IActuator);
 }
 
-int SCA_PropertyActuator::_setattr(const STR_String& attr, PyObject *value) {
+int SCA_PropertyActuator::_setattr(const char *attr, PyObject *value) {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)
 		return ret;

source/gameengine/GameLogic/SCA_PropertyActuator.h

@@ -85,8 +85,8 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject*  _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject*  _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	// python wrapped methods
 	KX_PYMETHOD_DOC(SCA_PropertyActuator,SetProperty);

source/gameengine/GameLogic/SCA_PropertySensor.cpp

@@ -352,14 +352,14 @@ PyAttributeDef SCA_PropertySensor::Attributes[] = {
 };
 
 
-PyObject* SCA_PropertySensor::_getattr(const STR_String& attr) {
+PyObject* SCA_PropertySensor::_getattr(const char *attr) {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
 		return object;
 	_getattr_up(SCA_ISensor); /* implicit return! */
 }
 
-int SCA_PropertySensor::_setattr(const STR_String& attr, PyObject *value) {
+int SCA_PropertySensor::_setattr(const char *attr, PyObject *value) {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)
 		return ret;

source/gameengine/GameLogic/SCA_PropertySensor.h

@@ -85,8 +85,8 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	/* 1. getType */
 	KX_PYMETHOD_DOC(SCA_PropertySensor,GetType);

source/gameengine/GameLogic/SCA_PythonController.cpp

@@ -233,8 +233,8 @@ PyMethodDef SCA_PythonController::Methods[] = {
 	{"getActuator", (PyCFunction) SCA_PythonController::sPyGetActuator, METH_O, (PY_METHODCHAR)SCA_PythonController::GetActuator_doc},
 	{"getSensors", (PyCFunction) SCA_PythonController::sPyGetSensors, METH_NOARGS, (PY_METHODCHAR)SCA_PythonController::GetSensors_doc},
 	{"getSensor", (PyCFunction) SCA_PythonController::sPyGetSensor, METH_O, (PY_METHODCHAR)SCA_PythonController::GetSensor_doc},
-	{"setScript", (PyCFunction) SCA_PythonController::sPySetScript, METH_O},
 	//Deprecated functions ------>
+	{"setScript", (PyCFunction) SCA_PythonController::sPySetScript, METH_O},
 	{"getScript", (PyCFunction) SCA_PythonController::sPyGetScript, METH_NOARGS},
 	{"getState", (PyCFunction) SCA_PythonController::sPyGetState, METH_NOARGS},
 	//<----- Deprecated
@@ -329,25 +329,35 @@ void SCA_PythonController::Trigger(SCA_LogicManager* logicmgr)
 
 
 
-PyObject* SCA_PythonController::_getattr(const STR_String& attr)
+PyObject* SCA_PythonController::_getattr(const char *attr)
 {
-	if (attr == "script") {
-		return PyString_FromString(m_scriptText);
-	}
-	if (attr == "state") {
+	if (!strcmp(attr,"state")) {
 		return PyInt_FromLong(m_statemask);
 	}
+	if (!strcmp(attr,"script")) {
+		return PyString_FromString(m_scriptText);
+	}
 	_getattr_up(SCA_IController);
 }
 
-int SCA_PythonController::_setattr(const STR_String& attr, PyObject *value)
+int SCA_PythonController::_setattr(const char *attr, PyObject *value)
 {
-	if (attr == "script") {
-		PyErr_SetString(PyExc_AttributeError, "script is read only, use setScript() to update the script");
+	if (!strcmp(attr,"state")) {
+		PyErr_SetString(PyExc_AttributeError, "state is read only");
 		return 1;
 	}
-	if (attr == "state") {
-		PyErr_SetString(PyExc_AttributeError, "state is read only");
+	if (!strcmp(attr,"script")) {
+		char *scriptArg = PyString_AsString(value);
+		
+		if (scriptArg==NULL) {
+			PyErr_SetString(PyExc_TypeError, "expected a string (script name)");
+			return -1;
+		}
+	
+		/* set scripttext sets m_bModified to true, 
+			so next time the script is needed, a reparse into byte code is done */
+		this->SetScriptText(scriptArg);
+		
 		return 1;
 	}
 	return SCA_IController::_setattr(attr, value);
@@ -448,6 +458,9 @@ PyObject* SCA_PythonController::PyGetScript(PyObject* self)
 PyObject* SCA_PythonController::PySetScript(PyObject* self, PyObject* value)
 {
 	char *scriptArg = PyString_AsString(value);
+	
+	ShowDeprecationWarning("setScript()", "the script property");
+	
 	if (scriptArg==NULL) {
 		PyErr_SetString(PyExc_TypeError, "expected a string (script name)");
 		return NULL;

source/gameengine/GameLogic/SCA_PythonController.h

@@ -76,8 +76,8 @@ class SCA_PythonController : public SCA_IController
 	static const char* sPyAddActiveActuator__doc__;
 	static PyObject* sPyAddActiveActuator(PyObject* self, 
 										  PyObject* args);
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	KX_PYMETHOD_DOC_NOARGS(SCA_PythonController,GetSensors);
 	KX_PYMETHOD_DOC_NOARGS(SCA_PythonController,GetActuators);

source/gameengine/GameLogic/SCA_RandomActuator.cpp

@@ -369,22 +369,22 @@ PyAttributeDef SCA_RandomActuator::Attributes[] = {
 	{ NULL }	//Sentinel
 };	
 
-PyObject* SCA_RandomActuator::_getattr(const STR_String& attr) {
+PyObject* SCA_RandomActuator::_getattr(const char *attr) {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
 		return object;
-	if (attr == "seed") {
+	if (!strcmp(attr, "seed")) {
 		return PyInt_FromLong(m_base->GetSeed());
 	}
 	_getattr_up(SCA_IActuator);
 }
 
-int SCA_RandomActuator::_setattr(const STR_String& attr, PyObject *value)
+int SCA_RandomActuator::_setattr(const char *attr, PyObject *value)
 {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)
 		return ret;
-	if (attr == "seed") {
+	if (!strcmp(attr, "seed")) {
 		if (PyInt_Check(value))	{
 			int ival = PyInt_AsLong(value);
 			m_base->SetSeed(ival);

source/gameengine/GameLogic/SCA_RandomActuator.h

@@ -96,8 +96,8 @@ class SCA_RandomActuator : public SCA_IActuator
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	/* 1. setSeed                                                            */
 	KX_PYMETHOD_DOC(SCA_RandomActuator,SetSeed);

source/gameengine/GameLogic/SCA_RandomSensor.cpp

@@ -165,22 +165,22 @@ PyAttributeDef SCA_RandomSensor::Attributes[] = {
 	{NULL} //Sentinel
 };
 
-PyObject* SCA_RandomSensor::_getattr(const STR_String& attr) {
+PyObject* SCA_RandomSensor::_getattr(const char *attr) {
 	PyObject* object = _getattr_self(Attributes, this, attr);
 	if (object != NULL)
 		return object;
-	if (attr == "seed") {
+	if (!strcmp(attr,"seed")) {
 		return PyInt_FromLong(m_basegenerator->GetSeed());
 	}
 	_getattr_up(SCA_ISensor);
 }
 
-int SCA_RandomSensor::_setattr(const STR_String& attr, PyObject *value)
+int SCA_RandomSensor::_setattr(const char *attr, PyObject *value)
 {
 	int ret = _setattr_self(Attributes, this, attr, value);
 	if (ret >= 0)
 		return ret;
-	if (attr == "seed") {
+	if (!strcmp(attr,"seed")) {
 		if (PyInt_Check(value))	{
 			int ival = PyInt_AsLong(value);
 			m_basegenerator->SetSeed(ival);

source/gameengine/GameLogic/SCA_RandomSensor.h

@@ -60,8 +60,8 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);
 
 	/* 1. setSeed                                                            */
 	KX_PYMETHOD_DOC(SCA_RandomSensor,SetSeed);

source/gameengine/GameLogic/SCA_XNORController.cpp

@@ -141,7 +141,7 @@ PyMethodDef SCA_XNORController::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* SCA_XNORController::_getattr(const STR_String& attr) {
+PyObject* SCA_XNORController::_getattr(const char *attr) {
 	_getattr_up(SCA_IController);
 }
 

source/gameengine/GameLogic/SCA_XNORController.h

@@ -48,7 +48,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 };
 

source/gameengine/GameLogic/SCA_XORController.cpp

@@ -141,7 +141,7 @@ PyMethodDef SCA_XORController::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* SCA_XORController::_getattr(const STR_String& attr) {
+PyObject* SCA_XORController::_getattr(const char *attr) {
 	_getattr_up(SCA_IController);
 }
 

source/gameengine/GameLogic/SCA_XORController.h

@@ -48,7 +48,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 };
 

source/gameengine/Ketsji/BL_Shader.cpp

@@ -729,7 +729,7 @@ void BL_Shader::SetUniform(int uniform, const int* val, int len)
 }
 
 
-PyObject* BL_Shader::_getattr(const STR_String& attr)
+PyObject* BL_Shader::_getattr(const char *attr)
 {
 	_getattr_up(PyObjectPlus);
 }

source/gameengine/Ketsji/BL_Shader.h

@@ -202,7 +202,7 @@ public:
 	void SetUniform(int uniform, const int val);
 
 	// Python interface
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	// -----------------------------------
 	KX_PYMETHOD_DOC( BL_Shader, setSource );

source/gameengine/Ketsji/BL_Texture.cpp

@@ -609,7 +609,7 @@ int BL_Texture::GetPow2(int n)
 
 void BL_Texture::SplitEnvMap(EnvMap *map)
 {
-	if (!map || !map->ima || map->ima && !map->ima->ok) return;
+	if (!map || !map->ima || (map->ima && !map->ima->ok)) return;
 	ImBuf *ibuf= BKE_image_get_ibuf(map->ima, NULL);
 	if (ibuf)
 		my_envmap_split_ima(map, ibuf);

source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp

@@ -143,7 +143,7 @@ PyMethodDef KX_NetworkMessageActuator::Methods[] = {
 	{NULL,NULL} // Sentinel
 };
 
-PyObject* KX_NetworkMessageActuator::_getattr(const STR_String& attr) {
+PyObject* KX_NetworkMessageActuator::_getattr(const char *attr) {
 	_getattr_up(SCA_IActuator);
 }
 

source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.h

@@ -61,7 +61,7 @@ public:
 	/* Python interface ------------------------------------------- */
 	/* ------------------------------------------------------------ */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	KX_PYMETHOD(KX_NetworkMessageActuator, SetToPropName);
 	KX_PYMETHOD(KX_NetworkMessageActuator, SetSubject);

source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp

@@ -213,7 +213,7 @@ PyMethodDef KX_NetworkMessageSensor::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* KX_NetworkMessageSensor::_getattr(const STR_String& attr) {
+PyObject* KX_NetworkMessageSensor::_getattr(const char *attr) {
 	_getattr_up(SCA_ISensor); // implicit return!
 }
 

source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.h

@@ -72,7 +72,7 @@ public:
 	/* Python interface -------------------------------------------- */
 	/* ------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	KX_PYMETHOD_DOC_O(KX_NetworkMessageSensor, SetSubjectFilterText);
 	KX_PYMETHOD_DOC_NOARGS(KX_NetworkMessageSensor, GetFrameMessageCount);

source/gameengine/Ketsji/KX_BlenderMaterial.cpp

@@ -772,12 +772,12 @@ PyParentObject KX_BlenderMaterial::Parents[] = {
 };
 
 
-PyObject* KX_BlenderMaterial::_getattr(const STR_String& attr)
+PyObject* KX_BlenderMaterial::_getattr(const char *attr)
 {
 	_getattr_up(PyObjectPlus);
 }
 
-int KX_BlenderMaterial::_setattr(const STR_String& attr, PyObject *pyvalue)
+int KX_BlenderMaterial::_setattr(const char *attr, PyObject *pyvalue)
 {
 	return PyObjectPlus::_setattr(attr, pyvalue);
 }

source/gameengine/Ketsji/KX_BlenderMaterial.h

@@ -82,8 +82,8 @@ public:
 	);
 	
 	// --------------------------------
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int       _setattr(const STR_String& attr, PyObject *pyvalue);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int       _setattr(const char *attr, PyObject *pyvalue);
 
 	KX_PYMETHOD_DOC( KX_BlenderMaterial, getShader );
 	KX_PYMETHOD_DOC( KX_BlenderMaterial, getMaterialIndex );

source/gameengine/Ketsji/KX_CDActuator.cpp

@@ -199,7 +199,7 @@ PyMethodDef KX_CDActuator::Methods[] = {
 
 
 
-PyObject* KX_CDActuator::_getattr(const STR_String& attr)
+PyObject* KX_CDActuator::_getattr(const char *attr)
 {
 	_getattr_up(SCA_IActuator);
 }

source/gameengine/Ketsji/KX_CDActuator.h

@@ -81,7 +81,7 @@ public:
 	/* Python interface --------------------------------------------------- */
 	/* -------------------------------------------------------------------- */
 
-	virtual PyObject*  _getattr(const STR_String& attr);
+	virtual PyObject*  _getattr(const char *attr);
 
 	KX_PYMETHOD(KX_CDActuator,StartCD);
 	KX_PYMETHOD(KX_CDActuator,PauseCD);

source/gameengine/Ketsji/KX_Camera.cpp

@@ -538,48 +538,48 @@ PyParentObject KX_Camera::Parents[] = {
 		NULL
 };
 
-PyObject* KX_Camera::_getattr(const STR_String& attr)
+PyObject* KX_Camera::_getattr(const char *attr)
 {
-	if (attr == "INSIDE")
+	if (!strcmp(attr, "INSIDE"))
 		return PyInt_FromLong(INSIDE); /* new ref */
-	if (attr == "OUTSIDE")
+	if (!strcmp(attr, "OUTSIDE"))
 		return PyInt_FromLong(OUTSIDE); /* new ref */
-	if (attr == "INTERSECT")
+	if (!strcmp(attr, "INTERSECT"))
 		return PyInt_FromLong(INTERSECT); /* new ref */
 	
-	if (attr == "lens")
+	if (!strcmp(attr, "lens"))
 		return PyFloat_FromDouble(GetLens()); /* new ref */
-	if (attr == "near")
+	if (!strcmp(attr, "near"))
 		return PyFloat_FromDouble(GetCameraNear()); /* new ref */
-	if (attr == "far")
+	if (!strcmp(attr, "far"))
 		return PyFloat_FromDouble(GetCameraFar()); /* new ref */
-	if (attr == "frustum_culling")
+	if (!strcmp(attr, "frustum_culling"))
 		return PyInt_FromLong(m_frustum_culling); /* new ref */
-	if (attr == "perspective")
+	if (!strcmp(attr, "perspective"))
 		return PyInt_FromLong(m_camdata.m_perspective); /* new ref */
-	if (attr == "projection_matrix")
+	if (!strcmp(attr, "projection_matrix"))
 		return PyObjectFrom(GetProjectionMatrix()); /* new ref */
-	if (attr == "modelview_matrix")
+	if (!strcmp(attr, "modelview_matrix"))
 		return PyObjectFrom(GetModelviewMatrix()); /* new ref */
-	if (attr == "camera_to_world")
+	if (!strcmp(attr, "camera_to_world"))
 		return PyObjectFrom(GetCameraToWorld()); /* new ref */
-	if (attr == "world_to_camera")
+	if (!strcmp(attr, "world_to_camera"))
 		return PyObjectFrom(GetWorldToCamera()); /* new ref */
 	
 	_getattr_up(KX_GameObject);
 }
 
-int KX_Camera::_setattr(const STR_String &attr, PyObject *pyvalue)
+int KX_Camera::_setattr(const char *attr, PyObject *pyvalue)
 {
 	if (PyInt_Check(pyvalue))
 	{
-		if (attr == "frustum_culling")
+		if (!strcmp(attr, "frustum_culling"))
 		{
 			m_frustum_culling = PyInt_AsLong(pyvalue);
 			return 0;
 		}
 		
-		if (attr == "perspective")
+		if (!strcmp(attr, "perspective"))
 		{
 			m_camdata.m_perspective = PyInt_AsLong(pyvalue);
 			return 0;
@@ -588,19 +588,19 @@ int KX_Camera::_setattr(const STR_String &attr, PyObject *pyvalue)
 	
 	if (PyFloat_Check(pyvalue))
 	{
-		if (attr == "lens")
+		if (!strcmp(attr, "lens"))
 		{
 			m_camdata.m_lens = PyFloat_AsDouble(pyvalue);
 			m_set_projection_matrix = false;
 			return 0;
 		}
-		if (attr == "near")
+		if (!strcmp(attr, "near"))
 		{
 			m_camdata.m_clipstart = PyFloat_AsDouble(pyvalue);
 			m_set_projection_matrix = false;
 			return 0;
 		}
-		if (attr == "far")
+		if (!strcmp(attr, "far"))
 		{
 			m_camdata.m_clipend = PyFloat_AsDouble(pyvalue);
 			m_set_projection_matrix = false;
@@ -610,7 +610,7 @@ int KX_Camera::_setattr(const STR_String &attr, PyObject *pyvalue)
 	
 	if (PyObject_IsMT_Matrix(pyvalue, 4))
 	{
-		if (attr == "projection_matrix")
+		if (!strcmp(attr, "projection_matrix"))
 		{
 			MT_Matrix4x4 mat;
 			if (PyMatTo(pyvalue, mat))

source/gameengine/Ketsji/KX_Camera.h

@@ -270,8 +270,8 @@ public:
 	KX_PYMETHOD_DOC(KX_Camera, setViewport);	
 	KX_PYMETHOD_DOC(KX_Camera, setOnTop);	
 
-	virtual PyObject* _getattr(const STR_String& attr); /* lens, near, far, projection_matrix */
-	virtual int       _setattr(const STR_String& attr, PyObject *pyvalue);
+	virtual PyObject* _getattr(const char *attr); /* lens, near, far, projection_matrix */
+	virtual int       _setattr(const char *attr, PyObject *pyvalue);
 
 };
 

source/gameengine/Ketsji/KX_CameraActuator.cpp

@@ -420,10 +420,10 @@ PyAttributeDef KX_CameraActuator::Attributes[] = {
 	{NULL}
 };
 
-PyObject* KX_CameraActuator::_getattr(const STR_String& attr) {
+PyObject* KX_CameraActuator::_getattr(const char *attr) {
 	PyObject* object;
 	
-	if (attr == "object") {
+	if (!strcmp(attr, "object")) {
 		if (!m_ob)	Py_RETURN_NONE;
 		else		return m_ob->AddRef();
 	}
@@ -434,10 +434,10 @@ PyObject* KX_CameraActuator::_getattr(const STR_String& attr) {
 	_getattr_up(SCA_IActuator);
 }
 
-int KX_CameraActuator::_setattr(const STR_String& attr, PyObject* value) {
+int KX_CameraActuator::_setattr(const char *attr, PyObject* value) {
 	int ret;
 	
-	if (attr == "object") {
+	if (!strcmp(attr, "object")) {
 		KX_GameObject *gameobj;
 		
 		if (!ConvertPythonToGameObject(value, &gameobj, true))

source/gameengine/Ketsji/KX_CameraActuator.h

@@ -120,8 +120,8 @@ private :
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject* value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject* value);
 
 	/* set object to look at */
 	KX_PYMETHOD_DOC_O(KX_CameraActuator,SetObject);

source/gameengine/Ketsji/KX_ConstraintActuator.cpp

@@ -612,7 +612,7 @@ PyMethodDef KX_ConstraintActuator::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* KX_ConstraintActuator::_getattr(const STR_String& attr) {
+PyObject* KX_ConstraintActuator::_getattr(const char *attr) {
 	_getattr_up(SCA_IActuator);
 }
 

source/gameengine/Ketsji/KX_ConstraintActuator.h

@@ -142,7 +142,7 @@ protected:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	KX_PYMETHOD_DOC(KX_ConstraintActuator,SetDamp);
 	KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetDamp);

source/gameengine/Ketsji/KX_ConstraintWrapper.cpp

@@ -92,32 +92,30 @@ PyParentObject KX_ConstraintWrapper::Parents[] = {
 	NULL
 };
 
-PyObject*	KX_ConstraintWrapper::_getattr(const STR_String& attr)
+PyObject*	KX_ConstraintWrapper::_getattr(const char *attr)
 {
 	//here you can search for existing data members (like mass,friction etc.)
 	_getattr_up(PyObjectPlus);
 }
 
-int	KX_ConstraintWrapper::_setattr(const STR_String& attr,PyObject* pyobj)
+int	KX_ConstraintWrapper::_setattr(const char *attr,PyObject* pyobj)
 {
-	
-	PyTypeObject* type = pyobj->ob_type;
 	int result = 1;
 
-	if (type == &PyList_Type)
+	if (PyList_Check(pyobj))
 	{
 		result = 0;
 	}
-	if (type == &PyFloat_Type)
+	if (PyFloat_Check(pyobj))
 	{
 		result = 0;
 
 	}
-	if (type == &PyInt_Type)
+	if (PyInt_Check(pyobj))
 	{
 		result = 0;
 	}
-	if (type == &PyString_Type)
+	if (PyString_Check(pyobj))
 	{
 		result = 0;
 	}

source/gameengine/Ketsji/KX_ConstraintWrapper.h

@@ -35,8 +35,8 @@
 class	KX_ConstraintWrapper : public PyObjectPlus
 {
 	Py_Header;
-	virtual PyObject*		_getattr(const STR_String& attr);
-	virtual int 			_setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject*		_getattr(const char *attr);
+	virtual int 			_setattr(const char *attr, PyObject *value);
 public:
 	KX_ConstraintWrapper(PHY_ConstraintType ctype,int constraintId,class PHY_IPhysicsEnvironment* physenv,PyTypeObject *T = &Type);
 	virtual ~KX_ConstraintWrapper ();

source/gameengine/Ketsji/KX_GameActuator.cpp

@@ -276,7 +276,7 @@ PyObject* KX_GameActuator::PySetFile(PyObject* self, PyObject* args, PyObject* k
 	
 
 
-PyObject* KX_GameActuator::_getattr(const STR_String& attr)
+PyObject* KX_GameActuator::_getattr(const char *attr)
 {
 	_getattr_up(SCA_IActuator);
 }

source/gameengine/Ketsji/KX_GameActuator.h

@@ -77,7 +77,7 @@ protected:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 	KX_PYMETHOD_DOC(KX_GameActuator,GetFile);
 	KX_PYMETHOD_DOC(KX_GameActuator,SetFile);
 	

source/gameengine/Ketsji/KX_GameObject.cpp

@@ -1124,15 +1124,15 @@ PyParentObject KX_GameObject::Parents[] = {
 
 
 
-PyObject* KX_GameObject::_getattr(const STR_String& attr)
+PyObject* KX_GameObject::_getattr(const char *attr)
 {
 	if (m_pPhysicsController1)
 	{
-		if (attr == "mass")
+		if (!strcmp(attr, "mass"))
 			return PyFloat_FromDouble(m_pPhysicsController1->GetMass());
 	}
 
-	if (attr == "parent")
+	if (!strcmp(attr, "parent"))
 	{	
 		KX_GameObject* parent = GetParent();
 		if (parent)
@@ -1143,21 +1143,23 @@ PyObject* KX_GameObject::_getattr(const STR_String& attr)
 		Py_RETURN_NONE;
 	}
 
-	if (attr == "visible")
+	if (!strcmp(attr, "visible"))
 		return PyInt_FromLong(m_bVisible);
 	
-	if (attr == "position")
+	if (!strcmp(attr, "position"))
 		return PyObjectFrom(NodeGetWorldPosition());
 	
-	if (attr == "orientation")
+	if (!strcmp(attr, "orientation"))
 		return PyObjectFrom(NodeGetWorldOrientation());
 	
-	if (attr == "scaling")
+	if (!strcmp(attr, "scaling"))
 		return PyObjectFrom(NodeGetWorldScaling());
 		
-	if (attr == "name")
+	if (!strcmp(attr, "name"))
 		return PyString_FromString(m_name.ReadPtr());
-	if (attr == "timeOffset") {
+	
+	if (!strcmp(attr, "timeOffset"))
+	{
 		if (m_pSGNode->GetSGParent()->IsSlowParent()) {
 			return PyFloat_FromDouble(static_cast<KX_SlowParentRelation *>(m_pSGNode->GetSGParent()->GetParentRelation())->GetTimeOffset());
 		} else {
@@ -1169,10 +1171,10 @@ PyObject* KX_GameObject::_getattr(const STR_String& attr)
 	_getattr_up(SCA_IObject);
 }
 
-int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr method
+int KX_GameObject::_setattr(const char *attr, PyObject *value)	// _setattr method
 {
 	
-	if (attr == "parent") {
+	if (!strcmp(attr, "parent")) {
 		PyErr_SetString(PyExc_AttributeError, "attribute \"mass\" is read only\nUse setParent()");
 		return 1;
 	}
@@ -1180,7 +1182,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 	if (PyInt_Check(value))
 	{
 		int val = PyInt_AsLong(value);
-		if (attr == "visible")
+		if (!strcmp(attr, "visible"))
 		{
 			SetVisible(val != 0, false);
 			UpdateBuckets(false);
@@ -1191,7 +1193,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 	if (PyFloat_Check(value))
 	{
 		MT_Scalar val = PyFloat_AsDouble(value);
-		if (attr == "timeOffset") {
+		if (!strcmp(attr, "timeOffset")) {
 			if (m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsSlowParent()) {
 				static_cast<KX_SlowParentRelation *>(m_pSGNode->GetSGParent()->GetParentRelation())->SetTimeOffset(val);
 				return 0;
@@ -1199,7 +1201,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 				return 0;
 			}		
 		}
-		if (attr == "mass") {
+		if (!strcmp(attr, "mass")) {
 			if (m_pPhysicsController1)
 				m_pPhysicsController1->SetMass(val);
 			return 0;
@@ -1208,7 +1210,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 	
 	if (PySequence_Check(value))
 	{
-		if (attr == "orientation")
+		if (!strcmp(attr, "orientation"))
 		{
 			MT_Matrix3x3 rot;
 			if (PyObject_IsMT_Matrix(value, 3))
@@ -1251,7 +1253,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 			return 1;
 		}
 		
-		if (attr == "position")
+		if (!strcmp(attr, "position"))
 		{
 			MT_Point3 pos;
 			if (PyVecTo(value, pos))
@@ -1263,7 +1265,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 			return 1;
 		}
 		
-		if (attr == "scaling")
+		if (!strcmp(attr, "scaling"))
 		{
 			MT_Vector3 scale;
 			if (PyVecTo(value, scale))
@@ -1278,7 +1280,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 	
 	if (PyString_Check(value))
 	{
-		if (attr == "name")
+		if (!strcmp(attr, "name"))	
 		{
 			m_name = PyString_AsString(value);
 			return 0;

source/gameengine/Ketsji/KX_GameObject.h

@@ -756,18 +756,8 @@ public:
 	 * @section Python interface functions.
 	 */
 
-	virtual 
-		PyObject*			
-	_getattr(
-		const STR_String& attr
-	);
- 
-	virtual 
-		int 
-	_setattr(
-		const STR_String& attr, 
-		PyObject *value
-	);		// _setattr method
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject *value);		// _setattr method
 
 	KX_PYMETHOD_NOARGS(KX_GameObject,GetPosition);
 	KX_PYMETHOD_O(KX_GameObject,SetPosition);

source/gameengine/Ketsji/KX_IpoActuator.cpp

@@ -457,7 +457,7 @@ PyMethodDef KX_IpoActuator::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* KX_IpoActuator::_getattr(const STR_String& attr) {
+PyObject* KX_IpoActuator::_getattr(const char *attr) {
 	_getattr_up(SCA_IActuator);
 }
 

source/gameengine/Ketsji/KX_IpoActuator.h

@@ -141,7 +141,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 	//KX_PYMETHOD_DOC
 	KX_PYMETHOD_DOC(KX_IpoActuator,Set);
 	KX_PYMETHOD_DOC(KX_IpoActuator,SetProperty);

source/gameengine/Ketsji/KX_Light.cpp

@@ -172,65 +172,59 @@ void KX_LightObject::UnbindShadowBuffer(RAS_IRasterizer *ras)
 	GPU_lamp_shadow_buffer_unbind(lamp);
 }
 
-PyObject* KX_LightObject::_getattr(const STR_String& attr)
+PyObject* KX_LightObject::_getattr(const char *attr)
 {
-	if (attr == "layer")
+	if (!strcmp(attr, "layer"))
 		return PyInt_FromLong(m_lightobj.m_layer);
 	
-	if (attr == "energy")
+	if (!strcmp(attr, "energy"))
 		return PyFloat_FromDouble(m_lightobj.m_energy);
 	
-	if (attr == "distance")
+	if (!strcmp(attr, "distance"))
 		return PyFloat_FromDouble(m_lightobj.m_distance);
 	
-	if (attr == "colour" || attr == "color")
+	if (!strcmp(attr, "colour") || !strcmp(attr, "color"))
 		return Py_BuildValue("[fff]", m_lightobj.m_red, m_lightobj.m_green, m_lightobj.m_blue);
 		
-	if (attr == "lin_attenuation")
+	if (!strcmp(attr, "lin_attenuation"))
 		return PyFloat_FromDouble(m_lightobj.m_att1);
 	
-	if (attr == "quad_attenuation")
+	if (!strcmp(attr, "quad_attenuation"))
 		return PyFloat_FromDouble(m_lightobj.m_att2);
 	
-	if (attr == "spotsize")
+	if (!strcmp(attr, "spotsize"))
 		return PyFloat_FromDouble(m_lightobj.m_spotsize);
 	
-	if (attr == "spotblend")
+	if (!strcmp(attr, "spotblend"))
 		return PyFloat_FromDouble(m_lightobj.m_spotblend);
 		
-	if (attr == "SPOT")
+	if (!strcmp(attr, "SPOT"))
 		return PyInt_FromLong(RAS_LightObject::LIGHT_SPOT);
 		
-	if (attr == "SUN")
+	if (!strcmp(attr, "SUN"))
 		return PyInt_FromLong(RAS_LightObject::LIGHT_SUN);
 	
-	if (attr == "NORMAL")
+	if (!strcmp(attr, "NORMAL"))
 		return PyInt_FromLong(RAS_LightObject::LIGHT_NORMAL);
 	
-	if (attr == "type")
+	if (!strcmp(attr, "type"))
 		return PyInt_FromLong(m_lightobj.m_type);
 		
 	_getattr_up(KX_GameObject);
 }
 
-int       KX_LightObject::_setattr(const STR_String& attr, PyObject *pyvalue)
-{
-	if (attr == "SPOT" || attr == "SUN" || attr == "NORMAL")
-	{
-		PyErr_Format(PyExc_RuntimeError, "Attribute %s is read only.", attr.ReadPtr());
-		return 1;
-	}
-	
+int       KX_LightObject::_setattr(const char *attr, PyObject *pyvalue)
+{	
 	if (PyInt_Check(pyvalue))
 	{
 		int value = PyInt_AsLong(pyvalue);
-		if (attr == "layer")
+		if (!strcmp(attr, "layer"))
 		{
 			m_lightobj.m_layer = value;
 			return 0;
 		}
 		
-		if (attr == "type")
+		if (!strcmp(attr, "type"))
 		{
 			if (value >= RAS_LightObject::LIGHT_SPOT && value <= RAS_LightObject::LIGHT_NORMAL)
 				m_lightobj.m_type = (RAS_LightObject::LightType) value;
@@ -241,37 +235,37 @@ int       KX_LightObject::_setattr(const STR_String& attr, PyObject *pyvalue)
 	if (PyFloat_Check(pyvalue))
 	{
 		float value = PyFloat_AsDouble(pyvalue);
-		if (attr == "energy")
+		if (!strcmp(attr, "energy"))
 		{
 			m_lightobj.m_energy = value;
 			return 0;
 		}
 	
-		if (attr == "distance")
+		if (!strcmp(attr, "distance"))
 		{
 			m_lightobj.m_distance = value;
 			return 0;
 		}
 		
-		if (attr == "lin_attenuation")
+		if (!strcmp(attr, "lin_attenuation"))
 		{
 			m_lightobj.m_att1 = value;
 			return 0;
 		}
 		
-		if (attr == "quad_attenuation")
+		if (!strcmp(attr, "quad_attenuation"))
 		{
 			m_lightobj.m_att2 = value;
 			return 0;
 		}
 		
-		if (attr == "spotsize")
+		if (!strcmp(attr, "spotsize"))
 		{
 			m_lightobj.m_spotsize = value;
 			return 0;
 		}
 		
-		if (attr == "spotblend")
+		if (!strcmp(attr, "spotblend"))
 		{
 			m_lightobj.m_spotblend = value;
 			return 0;
@@ -280,7 +274,7 @@ int       KX_LightObject::_setattr(const STR_String& attr, PyObject *pyvalue)
 
 	if (PySequence_Check(pyvalue))
 	{
-		if (attr == "colour" || attr == "color")
+		if (!strcmp(attr, "colour") || !strcmp(attr, "color"))
 		{
 			MT_Vector3 color;
 			if (PyVecTo(pyvalue, color))
@@ -294,6 +288,12 @@ int       KX_LightObject::_setattr(const STR_String& attr, PyObject *pyvalue)
 		}
 	}
 	
+	if (!strcmp(attr, "SPOT") || !strcmp(attr, "SUN") || !strcmp(attr, "NORMAL"))
+	{
+		PyErr_Format(PyExc_RuntimeError, "Attribute %s is read only.", attr);
+		return 1;
+	}
+	
 	return KX_GameObject::_setattr(attr, pyvalue);
 }
 

source/gameengine/Ketsji/KX_Light.h

@@ -63,8 +63,8 @@ public:
 	void UnbindShadowBuffer(class RAS_IRasterizer *ras);
 	void Update();
 	
-	virtual PyObject* _getattr(const STR_String& attr); /* lens, near, far, projection_matrix */
-	virtual int       _setattr(const STR_String& attr, PyObject *pyvalue);
+	virtual PyObject* _getattr(const char *attr); /* lens, near, far, projection_matrix */
+	virtual int       _setattr(const char *attr, PyObject *pyvalue);
 
 	virtual bool IsLight(void) { return true; }
 };

source/gameengine/Ketsji/KX_MeshProxy.cpp

@@ -93,9 +93,9 @@ void KX_MeshProxy::SetMeshModified(bool v)
 
 
 PyObject*
-KX_MeshProxy::_getattr(const STR_String& attr)
+KX_MeshProxy::_getattr(const char *attr)
 {
-	if (attr == "materials")
+	if (!strcmp(attr, "materials"))
 	{
 		PyObject *materials = PyList_New(0);
 		list<RAS_MeshMaterial>::iterator mit = m_meshobj->GetFirstMaterial();

source/gameengine/Ketsji/KX_MeshProxy.h

@@ -53,7 +53,7 @@ public:
 	virtual CValue*		GetReplica();
 
 // stuff for python integration
-	virtual PyObject*  _getattr(const STR_String& attr);
+	virtual PyObject*  _getattr(const char *attr);
 	KX_PYMETHOD(KX_MeshProxy,GetNumMaterials);
 	KX_PYMETHOD(KX_MeshProxy,GetMaterialName);
 	KX_PYMETHOD(KX_MeshProxy,GetTextureName);

source/gameengine/Ketsji/KX_MouseFocusSensor.cpp

@@ -331,7 +331,7 @@ PyMethodDef KX_MouseFocusSensor::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* KX_MouseFocusSensor::_getattr(const STR_String& attr) {
+PyObject* KX_MouseFocusSensor::_getattr(const char *attr) {
 	_getattr_up(SCA_MouseSensor);
 }
 

source/gameengine/Ketsji/KX_MouseFocusSensor.h

@@ -87,7 +87,7 @@ class KX_MouseFocusSensor : public SCA_MouseSensor
 	/* --------------------------------------------------------------------- */
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
-	virtual PyObject*  _getattr(const STR_String& attr);
+	virtual PyObject*  _getattr(const char *attr);
 
 	KX_PYMETHOD_DOC(KX_MouseFocusSensor,GetRayTarget);
 	KX_PYMETHOD_DOC(KX_MouseFocusSensor,GetRaySource);

source/gameengine/Ketsji/KX_NearSensor.cpp

@@ -320,7 +320,7 @@ PyMethodDef KX_NearSensor::Methods[] = {
 
 
 PyObject*
-KX_NearSensor::_getattr(const STR_String& attr)
+KX_NearSensor::_getattr(const char *attr)
 {
   _getattr_up(KX_TouchSensor);
 }

source/gameengine/Ketsji/KX_NearSensor.h

@@ -79,7 +79,7 @@ public:
 	virtual void RegisterSumo(KX_TouchEventManager *touchman);
 	virtual void UnregisterSumo(KX_TouchEventManager* touchman);
 	
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 };
 

source/gameengine/Ketsji/KX_ObjectActuator.cpp

@@ -332,7 +332,7 @@ PyMethodDef KX_ObjectActuator::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* KX_ObjectActuator::_getattr(const STR_String& attr) {
+PyObject* KX_ObjectActuator::_getattr(const char *attr) {
 	_getattr_up(SCA_IActuator);
 };
 

source/gameengine/Ketsji/KX_ObjectActuator.h

@@ -153,7 +153,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 	
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetForce);
 	KX_PYMETHOD(KX_ObjectActuator,SetForce);

source/gameengine/Ketsji/KX_ParentActuator.cpp

@@ -172,9 +172,9 @@ PyMethodDef KX_ParentActuator::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* KX_ParentActuator::_getattr(const STR_String& attr) {	
+PyObject* KX_ParentActuator::_getattr(const char *attr) {	
 	
-	if (attr == "object") {
+	if (!strcmp(attr, "object")) {
 		if (!m_ob)	Py_RETURN_NONE;
 		else		return m_ob->AddRef();
 	}
@@ -182,9 +182,9 @@ PyObject* KX_ParentActuator::_getattr(const STR_String& attr) {
 	_getattr_up(SCA_IActuator);
 }
 
-int KX_ParentActuator::_setattr(const STR_String& attr, PyObject* value) {
+int KX_ParentActuator::_setattr(const char *attr, PyObject* value) {
 	
-	if (attr == "object") {
+	if (!strcmp(attr, "object")) {
 		KX_GameObject *gameobj;
 		
 		if (!ConvertPythonToGameObject(value, &gameobj, true))

source/gameengine/Ketsji/KX_ParentActuator.h

@@ -76,8 +76,8 @@ class KX_ParentActuator : public SCA_IActuator
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject* value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject* value);
 
 	/* 1. setObject                                                            */
 	KX_PYMETHOD_DOC_O(KX_ParentActuator,SetObject);

source/gameengine/Ketsji/KX_PhysicsObjectWrapper.cpp

@@ -142,23 +142,21 @@ PyParentObject KX_PhysicsObjectWrapper::Parents[] = {
 	NULL
 };
 
-PyObject*	KX_PhysicsObjectWrapper::_getattr(const STR_String& attr)
+PyObject*	KX_PhysicsObjectWrapper::_getattr(const char *attr)
 {
 	_getattr_up(PyObjectPlus);
 }
 
 
-int	KX_PhysicsObjectWrapper::_setattr(const STR_String& attr,PyObject* pyobj)
+int	KX_PhysicsObjectWrapper::_setattr(const char *attr,PyObject *pyobj)
 {
-	PyTypeObject* type = pyobj->ob_type;
 	int result = 1;
 
-
-	if (type == &PyInt_Type)
+	if (PyInt_Check(pyobj))
 	{
 		result = 0;
 	}
-	if (type == &PyString_Type)
+	if (PyString_Check(pyobj))
 	{
 		result = 0;
 	}

source/gameengine/Ketsji/KX_PhysicsObjectWrapper.h

@@ -36,8 +36,8 @@ class	KX_PhysicsObjectWrapper : public PyObjectPlus
 {
 	Py_Header;
 
-	virtual PyObject*		_getattr(const STR_String& attr);
-	virtual int 			_setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject*		_getattr(const char *attr);
+	virtual int 			_setattr(const char *attr, PyObject *value);
 public:
 	KX_PhysicsObjectWrapper(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsEnvironment* physenv,PyTypeObject *T = &Type);
 	virtual ~KX_PhysicsObjectWrapper();

source/gameengine/Ketsji/KX_PolyProxy.cpp

@@ -77,18 +77,17 @@ PyMethodDef KX_PolyProxy::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject*
-KX_PolyProxy::_getattr(const STR_String& attr)
+PyObject* KX_PolyProxy::_getattr(const char *attr)
 {
-	if (attr == "matname")
+	if (!strcmp(attr, "matname"))
 	{
 		return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetMaterialName());
 	}
-	if (attr == "texture")
+	if (!strcmp(attr, "texture"))
 	{
 		return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetTextureName());
 	}
-	if (attr == "material")
+	if (!strcmp(attr, "material"))
 	{
 		RAS_IPolyMaterial *polymat = m_polygon->GetMaterial()->GetPolyMaterial();
 		if(polymat->GetFlag() & RAS_BLENDERMAT)
@@ -104,7 +103,7 @@ KX_PolyProxy::_getattr(const STR_String& attr)
 			return mat;
 		}
 	}
-	if (attr == "matid")
+	if (!strcmp(attr, "matid"))
 	{
 		// we'll have to scan through the material bucket of the mes and compare with 
 		// the one of the polygon
@@ -119,27 +118,27 @@ KX_PolyProxy::_getattr(const STR_String& attr)
 		}
 		return PyInt_FromLong(matid);
 	}
-	if (attr == "v1")
+	if (!strcmp(attr, "v1"))
 	{
 		return PyInt_FromLong(m_polygon->GetVertexOffset(0));
 	}
-	if (attr == "v2")
+	if (!strcmp(attr, "v2"))
 	{
 		return PyInt_FromLong(m_polygon->GetVertexOffset(1));
 	}
-	if (attr == "v3")
+	if (!strcmp(attr, "v3"))
 	{
 		return PyInt_FromLong(m_polygon->GetVertexOffset(2));
 	}
-	if (attr == "v4")
+	if (!strcmp(attr, "v4"))
 	{
 		return PyInt_FromLong(((m_polygon->VertexCount()>3)?m_polygon->GetVertexOffset(3):0));
 	}
-	if (attr == "visible")
+	if (!strcmp(attr, "visible"))
 	{
 		return PyInt_FromLong(m_polygon->IsVisible());
 	}
-	if (attr == "collide")
+	if (!strcmp(attr, "collide"))
 	{
 		return PyInt_FromLong(m_polygon->IsCollider());
 	}

source/gameengine/Ketsji/KX_PolyProxy.h

@@ -53,7 +53,7 @@ public:
 
 
 // stuff for python integration
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	KX_PYMETHOD_DOC_NOARGS(KX_PolyProxy,getMaterialIndex)
 	KX_PYMETHOD_DOC_NOARGS(KX_PolyProxy,getNumVertex)

source/gameengine/Ketsji/KX_PolygonMaterial.cpp

@@ -202,7 +202,7 @@ PyParentObject KX_PolygonMaterial::Parents[] = {
 	NULL
 };
 
-PyObject* KX_PolygonMaterial::_getattr(const STR_String& attr)
+PyObject* KX_PolygonMaterial::_getattr(const char *attr)
 {
 	if (attr == "texture")
 		return PyString_FromString(m_texturename.ReadPtr());
@@ -253,7 +253,7 @@ PyObject* KX_PolygonMaterial::_getattr(const STR_String& attr)
 	_getattr_up(PyObjectPlus);
 }
 
-int KX_PolygonMaterial::_setattr(const STR_String &attr, PyObject *pyvalue)
+int KX_PolygonMaterial::_setattr(const char *attr, PyObject *pyvalue)
 {
 	if (PyFloat_Check(pyvalue))
 	{

source/gameengine/Ketsji/KX_PolygonMaterial.h

@@ -115,8 +115,8 @@ public:
 	KX_PYMETHOD_DOC(KX_PolygonMaterial, setCustomMaterial);
 	KX_PYMETHOD_DOC(KX_PolygonMaterial, loadProgram);
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int       _setattr(const STR_String& attr, PyObject *pyvalue);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int       _setattr(const char *attr, PyObject *pyvalue);
 };
 
 #endif // __KX_POLYGONMATERIAL_H__

source/gameengine/Ketsji/KX_RadarSensor.cpp

@@ -229,7 +229,7 @@ PyMethodDef KX_RadarSensor::Methods[] = {
 	{NULL,NULL,NULL,NULL} //Sentinel
 };
 
-PyObject* KX_RadarSensor::_getattr(const STR_String& attr) {
+PyObject* KX_RadarSensor::_getattr(const char *attr) {
 	_getattr_up(KX_TouchSensor);
 }
 

source/gameengine/Ketsji/KX_RadarSensor.h

@@ -81,7 +81,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 	
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	KX_PYMETHOD_DOC(KX_RadarSensor,GetConeOrigin);
 	KX_PYMETHOD_DOC(KX_RadarSensor,GetConeTarget);

source/gameengine/Ketsji/KX_RaySensor.cpp

@@ -418,6 +418,6 @@ PyObject* KX_RaySensor::PyGetHitNormal(PyObject* self,
 
 
 
-PyObject* KX_RaySensor::_getattr(const STR_String& attr) {
+PyObject* KX_RaySensor::_getattr(const char *attr) {
 	_getattr_up(SCA_ISensor);
 }

source/gameengine/Ketsji/KX_RaySensor.h

@@ -79,7 +79,7 @@ public:
 	KX_PYMETHOD_DOC(KX_RaySensor,GetHitNormal);
 	KX_PYMETHOD_DOC(KX_RaySensor,GetRayDirection);
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 	
 };
 

source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp

@@ -205,9 +205,9 @@ PyMethodDef KX_SCA_AddObjectActuator::Methods[] = {
 };
 
 
-PyObject* KX_SCA_AddObjectActuator::_getattr(const STR_String& attr)
+PyObject* KX_SCA_AddObjectActuator::_getattr(const char *attr)
 {
-	if (attr == "object") {
+	if (!strcmp(attr, "object")) {
 		if (!m_OriginalObject)	Py_RETURN_NONE;
 		else					return m_OriginalObject->AddRef();
 	}
@@ -219,9 +219,9 @@ PyObject* KX_SCA_AddObjectActuator::_getattr(const STR_String& attr)
   _getattr_up(SCA_IActuator);
 }
 
-int KX_SCA_AddObjectActuator::_setattr(const STR_String& attr, PyObject* value) {
+int KX_SCA_AddObjectActuator::_setattr(const char *attr, PyObject* value) {
 	
-	if (attr == "object") {
+	if (!strcmp(attr, "object")) {
 		KX_GameObject *gameobj;
 		
 		if (!ConvertPythonToGameObject(value, &gameobj, true))

source/gameengine/Ketsji/KX_SCA_AddObjectActuator.h

@@ -110,8 +110,8 @@ public:
 	virtual bool 
 	Update();
 
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject* value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject* value);
 
 		SCA_IObject*	
 	GetLastCreatedObject(

source/gameengine/Ketsji/KX_SCA_DynamicActuator.cpp

@@ -87,7 +87,7 @@ PyMethodDef KX_SCA_DynamicActuator::Methods[] = {
 
 
 
-PyObject* KX_SCA_DynamicActuator::_getattr(const STR_String& attr)
+PyObject* KX_SCA_DynamicActuator::_getattr(const char *attr)
 {
   _getattr_up(SCA_IActuator);
 }

source/gameengine/Ketsji/KX_SCA_DynamicActuator.h

@@ -64,10 +64,7 @@ class KX_SCA_DynamicActuator : public SCA_IActuator
 	virtual bool 
 	Update();
 
-	virtual PyObject*  
-	_getattr(
-		const STR_String& attr
-	);
+	virtual PyObject* _getattr(const char *attr);
 
 	/* 1. setOperation */
 	KX_PYMETHOD_DOC(KX_SCA_DynamicActuator,setOperation);

source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp

@@ -128,7 +128,7 @@ PyMethodDef KX_SCA_EndObjectActuator::Methods[] = {
 };
 
 
-PyObject* KX_SCA_EndObjectActuator::_getattr(const STR_String& attr)
+PyObject* KX_SCA_EndObjectActuator::_getattr(const char *attr)
 {
   _getattr_up(SCA_IActuator);
 }

source/gameengine/Ketsji/KX_SCA_EndObjectActuator.h

@@ -64,10 +64,7 @@ class KX_SCA_EndObjectActuator : public SCA_IActuator
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject*  
-	_getattr(
-		const STR_String& attr
-	);
+	virtual PyObject* _getattr(const char *attr);
 	
 }; /* end of class KX_EditObjectActuator : public SCA_PropertyActuator */
 

source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp

@@ -91,7 +91,7 @@ PyMethodDef KX_SCA_ReplaceMeshActuator::Methods[] = {
 
 
 
-PyObject* KX_SCA_ReplaceMeshActuator::_getattr(const STR_String& attr)
+PyObject* KX_SCA_ReplaceMeshActuator::_getattr(const char *attr)
 {
   _getattr_up(SCA_IActuator);
 }

source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.h

@@ -69,10 +69,7 @@ class KX_SCA_ReplaceMeshActuator : public SCA_IActuator
 	virtual bool 
 	Update();
 
-	virtual PyObject*  
-	_getattr(
-		const STR_String& attr
-	);
+	virtual PyObject* _getattr(const char *attr);
 	void	InstantReplaceMesh();
 
 	/* 1. setMesh */

source/gameengine/Ketsji/KX_Scene.cpp

@@ -1544,28 +1544,28 @@ PyParentObject KX_Scene::Parents[] = {
 		NULL
 };
 
-PyObject* KX_Scene::_getattr(const STR_String& attr)
+PyObject* KX_Scene::_getattr(const char *attr)
 {
-	if (attr == "name")
+	if (!strcmp(attr, "name"))
 		return PyString_FromString(GetName());
 	
-	if (attr == "active_camera")
+	if (!strcmp(attr, "active_camera"))
 	{
 		KX_Camera *camera = GetActiveCamera();
 		camera->AddRef();
 		return (PyObject*) camera;
 	}
 	
-	if (attr == "suspended")
+	if (!strcmp(attr, "suspended"))
 		return PyInt_FromLong(m_suspend);
 	
-	if (attr == "activity_culling")
+	if (!strcmp(attr, "activity_culling"))
 		return PyInt_FromLong(m_activity_culling);
 	
-	if (attr == "activity_culling_radius")
+	if (!strcmp(attr, "activity_culling_radius"))
 		return PyFloat_FromDouble(m_activity_box_radius);
 	
-	PyObject* value = PyDict_GetItemString(m_attrlist, const_cast<char *>(attr.ReadPtr()));
+	PyObject* value = PyDict_GetItemString(m_attrlist, attr);
 	if (value)
 	{
 		Py_INCREF(value);
@@ -1575,16 +1575,15 @@ PyObject* KX_Scene::_getattr(const STR_String& attr)
 	_getattr_up(PyObjectPlus);
 }
 
-int KX_Scene::_delattr(const STR_String &attr)
+int KX_Scene::_delattr(const char *attr)
 {
-	PyDict_DelItemString(m_attrlist, const_cast<char *>(attr.ReadPtr()));
+	PyDict_DelItemString(m_attrlist, attr);
 	return 0;
 }
 
-int KX_Scene::_setattr(const STR_String &attr, PyObject *pyvalue)
+int KX_Scene::_setattr(const char *attr, PyObject *pyvalue)
 {
-
-	if (!PyDict_SetItemString(m_attrlist, const_cast<char *>(attr.ReadPtr()), pyvalue))
+	if (!PyDict_SetItemString(m_attrlist, attr, pyvalue))
 		return 0;
 
 	return PyObjectPlus::_setattr(attr, pyvalue);

source/gameengine/Ketsji/KX_Scene.h

@@ -564,9 +564,9 @@ public:
 	KX_PYMETHOD_DOC(KX_Scene, setSceneViewport);
 	*/
 
-	virtual PyObject* _getattr(const STR_String& attr); /* name, active_camera, gravity, suspended, viewport, framing, activity_culling, activity_culling_radius */
-	virtual int _setattr(const STR_String &attr, PyObject *pyvalue);
-	virtual int _delattr(const STR_String &attr);
+	virtual PyObject* _getattr(const char *attr); /* name, active_camera, gravity, suspended, viewport, framing, activity_culling, activity_culling_radius */
+	virtual int _setattr(const char *attr, PyObject *pyvalue);
+	virtual int _delattr(const char *attr);
 
 	/**
 	 * Sets the time the scene was suspended

source/gameengine/Ketsji/KX_SceneActuator.cpp

@@ -270,7 +270,7 @@ PyMethodDef KX_SceneActuator::Methods[] =
 
 
 
-PyObject* KX_SceneActuator::_getattr(const STR_String& attr)
+PyObject* KX_SceneActuator::_getattr(const char *attr)
 {
 	_getattr_up(SCA_IActuator);
 }

source/gameengine/Ketsji/KX_SceneActuator.h

@@ -92,7 +92,7 @@ class KX_SceneActuator : public SCA_IActuator
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	/* 1. set                                                                */
 	/* Removed */

source/gameengine/Ketsji/KX_SoundActuator.cpp

@@ -287,7 +287,7 @@ PyMethodDef KX_SoundActuator::Methods[] = {
 
 
 
-PyObject* KX_SoundActuator::_getattr(const STR_String& attr)
+PyObject* KX_SoundActuator::_getattr(const char *attr)
 {
 	_getattr_up(SCA_IActuator);
 }

source/gameengine/Ketsji/KX_SoundActuator.h

@@ -80,7 +80,7 @@ public:
 	/* Python interface --------------------------------------------------- */
 	/* -------------------------------------------------------------------- */
 
-	virtual PyObject*  _getattr(const STR_String& attr);
+	virtual PyObject*  _getattr(const char *attr);
 
 	KX_PYMETHOD(KX_SoundActuator,SetFilename);
 	KX_PYMETHOD(KX_SoundActuator,GetFilename);

source/gameengine/Ketsji/KX_StateActuator.cpp

@@ -146,10 +146,7 @@ KX_StateActuator::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* 
-KX_StateActuator::_getattr(
-	const STR_String& attr
-	) 
+PyObject* KX_StateActuator::_getattr(const char *attr)
 {
 	_getattr_up(SCA_IActuator);
 };

source/gameengine/Ketsji/KX_StateActuator.h

@@ -73,7 +73,7 @@ class KX_StateActuator : public SCA_IActuator
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 	//KX_PYMETHOD_DOC
 	KX_PYMETHOD_DOC(KX_StateActuator,SetOperation);
 	KX_PYMETHOD_DOC(KX_StateActuator,SetMask);

source/gameengine/Ketsji/KX_TouchSensor.cpp

@@ -261,7 +261,7 @@ PyMethodDef KX_TouchSensor::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* KX_TouchSensor::_getattr(const STR_String& attr) {
+PyObject* KX_TouchSensor::_getattr(const char *attr) {
 	_getattr_up(SCA_ISensor);
 }
 

source/gameengine/Ketsji/KX_TouchSensor.h

@@ -106,7 +106,7 @@ public:
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 	
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 
 	/* 1. setProperty */
 	KX_PYMETHOD_DOC(KX_TouchSensor,SetProperty);

source/gameengine/Ketsji/KX_TrackToActuator.cpp

@@ -470,9 +470,9 @@ PyMethodDef KX_TrackToActuator::Methods[] = {
 
 
 
-PyObject* KX_TrackToActuator::_getattr(const STR_String& attr)
+PyObject* KX_TrackToActuator::_getattr(const char *attr)
 {
-	if (attr == "object") {
+	if (!strcmp(attr, "object")) {
 		if (!m_object)		Py_RETURN_NONE;
 		else				return m_object->AddRef();
 	}
@@ -480,10 +480,10 @@ PyObject* KX_TrackToActuator::_getattr(const STR_String& attr)
 	_getattr_up(SCA_IActuator);
 }
 
-int KX_TrackToActuator::_setattr(const STR_String& attr, PyObject* value) {
+int KX_TrackToActuator::_setattr(const char *attr, PyObject* value) {
 	int ret;
 	
-	if (attr == "object") {
+	if (!strcmp(attr, "object")) {
 		KX_GameObject *gameobj;
 		
 		if (!ConvertPythonToGameObject(value, &gameobj, true))

source/gameengine/Ketsji/KX_TrackToActuator.h

@@ -72,8 +72,8 @@ class KX_TrackToActuator : public SCA_IActuator
 	virtual bool Update(double curtime, bool frame);
 
 	/* Python part */
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int _setattr(const STR_String& attr, PyObject* value);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int _setattr(const char *attr, PyObject* value);
 	
 	/* 1. setObject */
 	KX_PYMETHOD_DOC_O(KX_TrackToActuator,SetObject);

source/gameengine/Ketsji/KX_VehicleWrapper.cpp

@@ -322,13 +322,13 @@ PyParentObject KX_VehicleWrapper::Parents[] = {
 	NULL
 };
 
-PyObject*	KX_VehicleWrapper::_getattr(const STR_String& attr)
+PyObject*	KX_VehicleWrapper::_getattr(const char *attr)
 {
 	//here you can search for existing data members (like mass,friction etc.)
 	_getattr_up(PyObjectPlus);
 }
 
-int	KX_VehicleWrapper::_setattr(const STR_String& attr,PyObject* pyobj)
+int	KX_VehicleWrapper::_setattr(const char *attr,PyObject* pyobj)
 {
 	
 	PyTypeObject* type = pyobj->ob_type;

source/gameengine/Ketsji/KX_VehicleWrapper.h

@@ -12,8 +12,8 @@ class PHY_IMotionState;
 class	KX_VehicleWrapper : public PyObjectPlus
 {
 	Py_Header;
-	virtual PyObject*		_getattr(const STR_String& attr);
-	virtual int 			_setattr(const STR_String& attr, PyObject *value);
+	virtual PyObject*		_getattr(const char *attr);
+	virtual int 			_setattr(const char *attr, PyObject *value);
 
 	std::vector<PHY_IMotionState*> m_motionStates;
 

source/gameengine/Ketsji/KX_VertexProxy.cpp

@@ -79,15 +79,43 @@ PyMethodDef KX_VertexProxy::Methods[] = {
 };
 
 PyObject*
-KX_VertexProxy::_getattr(const STR_String& attr)
+KX_VertexProxy::_getattr(const char *attr)
 {
-  if (attr == "XYZ")
+  
+  if (attr[1]=='\0') { // Group single letters
+    // pos
+    if (attr[0]=='x')
+    	return PyFloat_FromDouble(m_vertex->getXYZ()[0]);
+    if (attr[0]=='y')
+    	return PyFloat_FromDouble(m_vertex->getXYZ()[1]);
+    if (attr[0]=='z')
+    	return PyFloat_FromDouble(m_vertex->getXYZ()[2]);
+
+    // Col
+    if (attr[0]=='r')
+    	return PyFloat_FromDouble(m_vertex->getRGBA()[0]/255.0);
+    if (attr[0]=='g')
+    	return PyFloat_FromDouble(m_vertex->getRGBA()[1]/255.0);
+    if (attr[0]=='b')
+    	return PyFloat_FromDouble(m_vertex->getRGBA()[2]/255.0);
+    if (attr[0]=='a')
+    	return PyFloat_FromDouble(m_vertex->getRGBA()[3]/255.0);
+
+    // UV
+    if (attr[0]=='u')
+    	return PyFloat_FromDouble(m_vertex->getUV1()[0]);
+    if (attr[0]=='v')
+    	return PyFloat_FromDouble(m_vertex->getUV1()[1]);
+  }
+  
+  
+  if (!strcmp(attr, "XYZ"))
   	return PyObjectFrom(MT_Vector3(m_vertex->getXYZ()));
 
-  if (attr == "UV")
+  if (!strcmp(attr, "UV"))
   	return PyObjectFrom(MT_Point2(m_vertex->getUV1()));
 
-  if (attr == "colour" || attr == "color")
+  if (!strcmp(attr, "color") || !strcmp(attr, "colour"))
   {
   	const unsigned char *colp = m_vertex->getRGBA();
 	MT_Vector4 color(colp[0], colp[1], colp[2], colp[3]);
@@ -95,43 +123,19 @@ KX_VertexProxy::_getattr(const STR_String& attr)
   	return PyObjectFrom(color);
   }
   
-  if (attr == "normal")
+  if (!strcmp(attr, "normal"))
   {
 	return PyObjectFrom(MT_Vector3(m_vertex->getNormal()));
   }
-
-  // pos
-  if (attr == "x")
-  	return PyFloat_FromDouble(m_vertex->getXYZ()[0]);
-  if (attr == "y")
-  	return PyFloat_FromDouble(m_vertex->getXYZ()[1]);
-  if (attr == "z")
-  	return PyFloat_FromDouble(m_vertex->getXYZ()[2]);
-
-  // Col
-  if (attr == "r")
-  	return PyFloat_FromDouble(m_vertex->getRGBA()[0]/255.0);
-  if (attr == "g")
-  	return PyFloat_FromDouble(m_vertex->getRGBA()[1]/255.0);
-  if (attr == "b")
-  	return PyFloat_FromDouble(m_vertex->getRGBA()[2]/255.0);
-  if (attr == "a")
-  	return PyFloat_FromDouble(m_vertex->getRGBA()[3]/255.0);
-
-  // UV
-  if (attr == "u")
-  	return PyFloat_FromDouble(m_vertex->getUV1()[0]);
-  if (attr == "v")
-  	return PyFloat_FromDouble(m_vertex->getUV1()[1]);
-
+  
   _getattr_up(SCA_IObject);
 }
 
-int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
+int    KX_VertexProxy::_setattr(const char *attr, PyObject *pyvalue)
 {
   if (PySequence_Check(pyvalue))
   {
-  	if (attr == "XYZ")
+	if (!strcmp(attr, "XYZ"))
 	{
 		MT_Point3 vec;
 		if (PyVecTo(pyvalue, vec))
@@ -143,7 +147,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		return 1;
 	}
 	
-	if (attr == "UV")
+	if (!strcmp(attr, "UV"))
 	{
 		MT_Point2 vec;
 		if (PyVecTo(pyvalue, vec))
@@ -155,7 +159,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		return 1;
 	}
 	
-	if (attr == "colour" || attr == "color")
+	if (!strcmp(attr, "color") || !strcmp(attr, "colour"))
 	{
 		MT_Vector4 vec;
 		if (PyVecTo(pyvalue, vec))
@@ -167,7 +171,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		return 1;
 	}
 	
-	if (attr == "normal")
+	if (!strcmp(attr, "normal"))
 	{
 		MT_Vector3 vec;
 		if (PyVecTo(pyvalue, vec))
@@ -185,7 +189,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
   	float val = PyFloat_AsDouble(pyvalue);
   	// pos
 	MT_Point3 pos(m_vertex->getXYZ());
-  	if (attr == "x")
+  	if (!strcmp(attr, "x"))
 	{
 		pos.x() = val;
 		m_vertex->SetXYZ(pos);
@@ -193,7 +197,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		return 0;
 	}
 	
-  	if (attr == "y")
+  	if (!strcmp(attr, "y"))
 	{
 		pos.y() = val;
 		m_vertex->SetXYZ(pos);
@@ -201,7 +205,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		return 0;
 	}
 	
-	if (attr == "z")
+	if (!strcmp(attr, "z"))
 	{
 		pos.z() = val;
 		m_vertex->SetXYZ(pos);
@@ -211,7 +215,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	
 	// uv
 	MT_Point2 uv = m_vertex->getUV1();
-	if (attr == "u")
+	if (!strcmp(attr, "u"))
 	{
 		uv[0] = val;
 		m_vertex->SetUV(uv);
@@ -219,7 +223,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		return 0;
 	}
 
-	if (attr == "v")
+	if (!strcmp(attr, "v"))
 	{
 		uv[1] = val;
 		m_vertex->SetUV(uv);
@@ -229,7 +233,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 
 	// uv
 	MT_Point2 uv2 = m_vertex->getUV2();
-	if (attr == "u2")
+	if (!strcmp(attr, "u2"))
 	{
 		uv[0] = val;
 		m_vertex->SetUV2(uv);
@@ -237,7 +241,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		return 0;
 	}
 
-	if (attr == "v2")
+	if (!strcmp(attr, "v2"))
 	{
 		uv[1] = val;
 		m_vertex->SetUV2(uv);
@@ -249,28 +253,28 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	unsigned int icol = *((const unsigned int *)m_vertex->getRGBA());
 	unsigned char *cp = (unsigned char*) &icol;
 	val *= 255.0;
-	if (attr == "r")
+	if (!strcmp(attr, "r"))
 	{
 		cp[0] = (unsigned char) val;
 		m_vertex->SetRGBA(icol);
 		m_mesh->SetMeshModified(true);
 		return 0;
 	}
-	if (attr == "g")
+	if (!strcmp(attr, "g"))
 	{
 		cp[1] = (unsigned char) val;
 		m_vertex->SetRGBA(icol);
 		m_mesh->SetMeshModified(true);
 		return 0;
 	}
-	if (attr == "b")
+	if (!strcmp(attr, "b"))
 	{
 		cp[2] = (unsigned char) val;
 		m_vertex->SetRGBA(icol);
 		m_mesh->SetMeshModified(true);
 		return 0;
 	}
-	if (attr == "a")
+	if (!strcmp(attr, "a"))
 	{
 		cp[3] = (unsigned char) val;
 		m_vertex->SetRGBA(icol);

source/gameengine/Ketsji/KX_VertexProxy.h

@@ -54,8 +54,8 @@ public:
 
 
 // stuff for python integration
-	virtual PyObject* _getattr(const STR_String& attr);
-	virtual int    _setattr(const STR_String& attr, PyObject *pyvalue);
+	virtual PyObject* _getattr(const char *attr);
+	virtual int    _setattr(const char *attr, PyObject *pyvalue);
 
 	KX_PYMETHOD(KX_VertexProxy,GetXYZ);
 	KX_PYMETHOD(KX_VertexProxy,SetXYZ);

source/gameengine/Ketsji/KX_VisibilityActuator.cpp

@@ -126,10 +126,7 @@ KX_VisibilityActuator::Methods[] = {
 	{NULL,NULL} //Sentinel
 };
 
-PyObject* 
-KX_VisibilityActuator::_getattr(
-	const STR_String& attr
-	) 
+PyObject* KX_VisibilityActuator::_getattr(const char *attr) 
 {
 	_getattr_up(SCA_IActuator);
 };

source/gameengine/Ketsji/KX_VisibilityActuator.h

@@ -67,7 +67,7 @@ class KX_VisibilityActuator : public SCA_IActuator
 	/* Python interface ---------------------------------------------------- */
 	/* --------------------------------------------------------------------- */
 
-	virtual PyObject* _getattr(const STR_String& attr);
+	virtual PyObject* _getattr(const char *attr);
 	//KX_PYMETHOD_DOC
 	KX_PYMETHOD_DOC(KX_VisibilityActuator,SetVisible);