griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

BGE Python API

Browse Source 
- 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.
This commit is contained in:
Campbell Barton
2009-04-19 21:01:12 +00:00
parent d78eec9319
commit f5fc4ebdd8
30 changed files with 300 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
source/gameengine/Converter/BL_ActionActuator.cpp
View File

@@ -1037,7 +1037,7 @@ int BL_ActionActuator::pyattr_set_action(void *self_v, const KX_PYATTRIBUTE_DEF
if (!PyString_Check(value))
{
PyErr_SetString(PyExc_ValueError, "expected the string name of the action");
PyErr_SetString(PyExc_ValueError, "actuator.action = val: Action Actuator, expected the string name of the action");
return -1;
}
@@ -1049,7 +1049,7 @@ int BL_ActionActuator::pyattr_set_action(void *self_v, const KX_PYATTRIBUTE_DEF
action= (bAction*)SCA_ILogicBrick::m_sCurrentLogicManager->GetActionByName(val);
if (!action)
{
PyErr_SetString(PyExc_ValueError, "action not found!");
PyErr_SetString(PyExc_ValueError, "actuator.action = val: Action Actuator, action not found!");
return 1;
}
}

2
source/gameengine/Converter/BL_ActionActuator.h
View File

@@ -154,7 +154,7 @@ public:
case ACT_ACTION_FROM_PROP:
return 0;
default:
PyErr_SetString(PyExc_ValueError, "invalid type supplied");
PyErr_SetString(PyExc_ValueError, "Action Actuator, invalid play type supplied");
return 1;
}
}

4
source/gameengine/Converter/BL_ShapeActionActuator.cpp
View File

@@ -869,7 +869,7 @@ int BL_ShapeActionActuator::pyattr_set_action(void *self_v, const KX_PYATTRIBUTE
/* exact copy of BL_ActionActuator's function from here down */
if (!PyString_Check(value))
{
PyErr_SetString(PyExc_ValueError, "expected the string name of the action");
PyErr_SetString(PyExc_ValueError, "actuator.action = val: Shape Action Actuator, expected the string name of the action");
return -1;
}
@@ -881,7 +881,7 @@ int BL_ShapeActionActuator::pyattr_set_action(void *self_v, const KX_PYATTRIBUTE
action= (bAction*)SCA_ILogicBrick::m_sCurrentLogicManager->GetActionByName(val);
if (action==NULL)
{
PyErr_SetString(PyExc_ValueError, "action not found!");
PyErr_SetString(PyExc_ValueError, "actuator.action = val: Shape Action Actuator, action not found!");
return 1;
}
}

2
source/gameengine/Converter/BL_ShapeActionActuator.h
View File

@@ -144,7 +144,7 @@ public:
case ACT_ACTION_FROM_PROP:
return 0;
default:
PyErr_SetString(PyExc_ValueError, "invalid type supplied");
PyErr_SetString(PyExc_ValueError, "Shape Action Actuator, invalid play type supplied");
return 1;
}

12
source/gameengine/Expressions/ListValue.cpp
View File

@@ -58,7 +58,7 @@ PyObject* listvalue_buffer_item(PyObject* self, Py_ssize_t index)
return list->GetValue(index)->GetProxy();
}
PyErr_SetString(PyExc_IndexError, "Python ListIndex out of range");
PyErr_SetString(PyExc_IndexError, "list[i]: Python ListIndex out of range in CValueList");
return NULL;
}
@@ -85,7 +85,7 @@ PyObject* listvalue_mapping_subscript(PyObject* self, PyObject* pyindex)
}
PyObject *pyindex_str = PyObject_Repr(pyindex); /* new ref */
PyErr_Format(PyExc_KeyError, "'%s' not in list", PyString_AsString(pyindex_str));
PyErr_Format(PyExc_KeyError, "list[key]: '%s' key not in list", PyString_AsString(pyindex_str));
Py_DECREF(pyindex_str);
return NULL;
}
@@ -162,7 +162,7 @@ listvalue_buffer_concat(PyObject * self, PyObject * other)
}
if (error) {
PyErr_SetString(PyExc_SystemError, "Python Error: couldn't add one or more items to a list");
PyErr_SetString(PyExc_SystemError, "list.append(val): couldn't add one or more items to this CValueList");
return NULL;
}
@@ -187,7 +187,7 @@ listvalue_buffer_concat(PyObject * self, PyObject * other)
listval->Add(objval);
} else
{
PyErr_SetString(PyExc_SystemError, "Python Error: couldn't add item to a list");
PyErr_SetString(PyExc_SystemError, "list.append(i): couldn't add item to this CValueList");
return NULL;
}
}
@@ -495,7 +495,7 @@ PyObject* CListValue::Pyindex(PyObject *value)
checkobj->Release();
if (result==NULL) {
PyErr_SetString(PyExc_ValueError, "ValueError: list.index(x): x not in CListValue");
PyErr_SetString(PyExc_ValueError, "list.index(x): x not in CListValue");
}
return result;
@@ -543,7 +543,7 @@ PyObject* CListValue::Pyfrom_id(PyObject* value)
if (reinterpret_cast<uintptr_t>(m_pValueArray[i]->m_proxy) == id)
return GetValue(i)->GetProxy();
}
PyErr_SetString(PyExc_IndexError, "from_id(#), id not found in CValueList");
PyErr_SetString(PyExc_IndexError, "from_id(#): id not found in CValueList");
return NULL;
}

56
source/gameengine/Expressions/PyObjectPlus.cpp
View File

@@ -325,12 +325,12 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
{
if (!PySequence_Check(value))
{
PyErr_SetString(PyExc_TypeError, "expected a sequence");
PyErr_Format(PyExc_TypeError, "expected a sequence for attribute \"%s\"", attrdef->m_name);
return 1;
}
if (PySequence_Size(value) != attrdef->m_length)
{
PyErr_SetString(PyExc_TypeError, "incorrect number of elements in sequence");
PyErr_Format(PyExc_TypeError, "incorrect number of elements in sequence for attribute \"%s\"", attrdef->m_name);
return 1;
}
switch (attrdef->m_type)
@@ -338,7 +338,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
case KX_PYATTRIBUTE_TYPE_FUNCTION:
if (attrdef->m_setFunction == NULL)
{
PyErr_SetString(PyExc_AttributeError, "function attribute without function, report to blender.org");
PyErr_Format(PyExc_AttributeError, "function attribute without function for attribute \"%s\", report to blender.org", attrdef->m_name);
return 1;
}
return (*attrdef->m_setFunction)(self, attrdef, value);
@@ -357,7 +357,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
break;
default:
// should not happen
PyErr_SetString(PyExc_AttributeError, "Unsupported attribute type, report to blender.org");
PyErr_Format(PyExc_AttributeError, "Unsupported attribute type for attribute \"%s\", report to blender.org", attrdef->m_name);
return 1;
}
// let's implement a smart undo method
@@ -390,7 +390,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
else
{
PyErr_SetString(PyExc_TypeError, "expected an integer or a bool");
PyErr_Format(PyExc_TypeError, "expected an integer or a bool for attribute \"%s\"", attrdef->m_name);
goto UNDO_AND_ERROR;
}
break;
@@ -411,14 +411,14 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
else if (val < attrdef->m_imin || val > attrdef->m_imax)
{
PyErr_SetString(PyExc_ValueError, "item value out of range");
PyErr_Format(PyExc_ValueError, "item value out of range for attribute \"%s\"", attrdef->m_name);
goto UNDO_AND_ERROR;
}
*var = (short int)val;
}
else
{
PyErr_SetString(PyExc_TypeError, "expected an integer");
PyErr_Format(PyExc_TypeError, "expected an integer for attribute \"%s\"", attrdef->m_name);
goto UNDO_AND_ERROR;
}
break;
@@ -427,7 +427,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
// enum are equivalent to int, just make sure that the field size matches:
if (sizeof(int) != attrdef->m_size)
{
PyErr_SetString(PyExc_AttributeError, "attribute size check error, report to blender.org");
PyErr_Format(PyExc_AttributeError, "Size check error for attribute, \"%s\", report to blender.org", attrdef->m_name);
goto UNDO_AND_ERROR;
}
// walkthrough
@@ -447,14 +447,14 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
else if (val < attrdef->m_imin || val > attrdef->m_imax)
{
PyErr_SetString(PyExc_ValueError, "item value out of range");
PyErr_Format(PyExc_ValueError, "item value out of range for attribute \"%s\"", attrdef->m_name);
goto UNDO_AND_ERROR;
}
*var = (int)val;
}
else
{
PyErr_SetString(PyExc_TypeError, "expected an integer");
PyErr_Format(PyExc_TypeError, "expected an integer for attribute \"%s\"", attrdef->m_name);
goto UNDO_AND_ERROR;
}
break;
@@ -466,7 +466,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
double val = PyFloat_AsDouble(item);
if (val == -1.0 && PyErr_Occurred())
{
PyErr_SetString(PyExc_TypeError, "expected a float");
PyErr_Format(PyExc_TypeError, "expected a float for attribute \"%s\"", attrdef->m_name);
goto UNDO_AND_ERROR;
}
else if (attrdef->m_clamp)
@@ -478,7 +478,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
else if (val < attrdef->m_fmin || val > attrdef->m_fmax)
{
PyErr_SetString(PyExc_ValueError, "item value out of range");
PyErr_Format(PyExc_ValueError, "item value out of range for attribute \"%s\"", attrdef->m_name);
goto UNDO_AND_ERROR;
}
*var = (float)val;
@@ -486,7 +486,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
default:
// should not happen
PyErr_SetString(PyExc_AttributeError, "attribute type check error, report to blender.org");
PyErr_Format(PyExc_AttributeError, "type check error for attribute \"%s\", report to blender.org", attrdef->m_name);
goto UNDO_AND_ERROR;
}
}
@@ -515,7 +515,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
{
if (attrdef->m_setFunction == NULL)
{
PyErr_SetString(PyExc_AttributeError, "function attribute without function, report to blender.org");
PyErr_Format(PyExc_AttributeError, "function attribute without function \"%s\", report to blender.org", attrdef->m_name);
return 1;
}
return (*attrdef->m_setFunction)(self, attrdef, value);
@@ -545,7 +545,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
bufferSize = strlen(reinterpret_cast<char*>(sourceBuffer))+1;
break;
default:
PyErr_SetString(PyExc_AttributeError, "unknown attribute type, report to blender.org");
PyErr_Format(PyExc_AttributeError, "unknown type for attribute \"%s\", report to blender.org", attrdef->m_name);
return 1;
}
if (bufferSize)
@@ -573,7 +573,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
else
{
PyErr_SetString(PyExc_TypeError, "expected an integer or a bool");
PyErr_Format(PyExc_TypeError, "expected an integer or a bool for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
break;
@@ -593,14 +593,14 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
else if (val < attrdef->m_imin || val > attrdef->m_imax)
{
PyErr_SetString(PyExc_ValueError, "value out of range");
PyErr_Format(PyExc_ValueError, "value out of range for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
*var = (short int)val;
}
else
{
PyErr_SetString(PyExc_TypeError, "expected an integer");
PyErr_Format(PyExc_TypeError, "expected an integer for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
break;
@@ -609,7 +609,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
// enum are equivalent to int, just make sure that the field size matches:
if (sizeof(int) != attrdef->m_size)
{
PyErr_SetString(PyExc_AttributeError, "attribute size check error, report to blender.org");
PyErr_Format(PyExc_AttributeError, "attribute size check error for attribute \"%s\", report to blender.org", attrdef->m_name);
goto FREE_AND_ERROR;
}
// walkthrough
@@ -628,14 +628,14 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
else if (val < attrdef->m_imin || val > attrdef->m_imax)
{
PyErr_SetString(PyExc_ValueError, "value out of range");
PyErr_Format(PyExc_ValueError, "value out of range for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
*var = (int)val;
}
else
{
PyErr_SetString(PyExc_TypeError, "expected an integer");
PyErr_Format(PyExc_TypeError, "expected an integer for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
break;
@@ -646,7 +646,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
double val = PyFloat_AsDouble(value);
if (val == -1.0 && PyErr_Occurred())
{
PyErr_SetString(PyExc_TypeError, "expected a float");
PyErr_Format(PyExc_TypeError, "expected a float for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
else if (attrdef->m_clamp)
@@ -658,7 +658,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
else if (val < attrdef->m_fmin || val > attrdef->m_fmax)
{
PyErr_SetString(PyExc_ValueError, "value out of range");
PyErr_Format(PyExc_ValueError, "value out of range for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
*var = (float)val;
@@ -675,7 +675,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
if (strlen(val) < attrdef->m_imin)
{
// can't increase the length of the string
PyErr_SetString(PyExc_ValueError, "string length too short");
PyErr_Format(PyExc_ValueError, "string length too short for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
else if (strlen(val) > attrdef->m_imax)
@@ -689,21 +689,21 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
}
} else if (strlen(val) < attrdef->m_imin || strlen(val) > attrdef->m_imax)
{
PyErr_SetString(PyExc_ValueError, "string length out of range");
PyErr_Format(PyExc_ValueError, "string length out of range for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
*var = val;
}
else
{
PyErr_SetString(PyExc_TypeError, "expected a string");
PyErr_Format(PyExc_TypeError, "expected a string for attribute \"%s\"", attrdef->m_name);
goto FREE_AND_ERROR;
}
break;
}
default:
// should not happen
PyErr_SetString(PyExc_AttributeError, "unknown attribute type, report to blender.org");
PyErr_Format(PyExc_AttributeError, "unknown type for attribute \"%s\", report to blender.org", attrdef->m_name);
goto FREE_AND_ERROR;
}
}
@@ -787,7 +787,7 @@ PyObject *PyObjectPlus::PyisA(PyObject *value) // Python wrapper for isA
} else if (PyString_Check(value)) {
return PyBool_FromLong(isA(PyString_AsString(value)));
}
PyErr_SetString(PyExc_TypeError, "expected a type or a string");
PyErr_SetString(PyExc_TypeError, "object.isA(value): expected a type or a string");
return NULL;
}

2
source/gameengine/Expressions/Value.cpp
View File

@@ -671,7 +671,7 @@ CValue* CValue::ConvertPythonToValue(PyObject* pyobj)
} else
{
/* return an error value from the caller */
PyErr_SetString(PyExc_TypeError, "This python value could not be assigned to a game engine property");
PyErr_SetString(PyExc_TypeError, "This python type could not be converted to a to a game engine property");
}
return vallie;

2
source/gameengine/GameLogic/SCA_JoystickSensor.cpp
View File

@@ -601,7 +601,7 @@ PyObject* SCA_JoystickSensor::pyattr_get_axis_single(void *self_v, const KX_PYAT
SCA_Joystick *joy = self->m_pJoystickMgr->GetJoystickDevice(self->m_joyindex);
if(self->m_joymode != KX_JOYSENSORMODE_AXIS_SINGLE) {
PyErr_SetString(PyExc_TypeError, "joystick sensor is not an 'Single Axis' type");
PyErr_SetString(PyExc_TypeError, "val = sensor.axisSingle: Joystick Sensor, not 'Single Axis' type");
return NULL;
}

4
source/gameengine/GameLogic/SCA_KeyboardSensor.cpp
View File

@@ -590,7 +590,7 @@ KX_PYMETHODDEF_DOC_O(SCA_KeyboardSensor, getKeyStatus,
"\tGet the given key's status (KX_NO_INPUTSTATUS, KX_JUSTACTIVATED, KX_ACTIVE or KX_JUSTRELEASED).\n")
{
if (!PyInt_Check(value)) {
PyErr_SetString(PyExc_ValueError, "getKeyStatus expected an int");
PyErr_SetString(PyExc_ValueError, "sensor.getKeyStatus(int): Keyboard Sensor, expected an int");
return NULL;
}
@@ -598,7 +598,7 @@ KX_PYMETHODDEF_DOC_O(SCA_KeyboardSensor, getKeyStatus,
if ((keycode < SCA_IInputDevice::KX_BEGINKEY)
|| (keycode > SCA_IInputDevice::KX_ENDKEY)){
PyErr_SetString(PyExc_AttributeError, "invalid keycode specified!");
PyErr_SetString(PyExc_AttributeError, "sensor.getKeyStatus(int): Keyboard Sensor, invalid keycode specified!");
return NULL;
}

2
source/gameengine/GameLogic/SCA_MouseSensor.cpp
View File

@@ -279,7 +279,7 @@ KX_PYMETHODDEF_DOC_O(SCA_MouseSensor, getButtonStatus,
if ((button < SCA_IInputDevice::KX_LEFTMOUSE)
|| (button > SCA_IInputDevice::KX_RIGHTMOUSE)){
PyErr_SetString(PyExc_ValueError, "invalid button specified!");
PyErr_SetString(PyExc_ValueError, "sensor.getButtonStatus(int): Mouse Sensor, invalid button specified!");
return NULL;
}

16
source/gameengine/GameLogic/SCA_PythonController.cpp
View File

@@ -187,7 +187,7 @@ SCA_IActuator* SCA_PythonController::LinkedActuatorFromPy(PyObject *value)
/* set the exception */
PyObject *value_str = PyObject_Repr(value); /* new ref */
PyErr_Format(PyExc_ValueError, "'%s' not in this controllers actuator list", PyString_AsString(value_str));
PyErr_Format(PyExc_ValueError, "'%s' not in this python controllers actuator list", PyString_AsString(value_str));
Py_DECREF(value_str);
return false;
@@ -417,14 +417,14 @@ PyObject* SCA_PythonController::PyGetActuators()
}
const char SCA_PythonController::GetSensor_doc[] =
"GetSensor (char sensorname) return linked sensor that is named [sensorname]\n";
"getSensor (char sensorname) return linked sensor that is named [sensorname]\n";
PyObject*
SCA_PythonController::PyGetSensor(PyObject* value)
{
char *scriptArg = PyString_AsString(value);
if (scriptArg==NULL) {
PyErr_SetString(PyExc_TypeError, "expected a string (sensor name)");
PyErr_SetString(PyExc_TypeError, "controller.getSensor(string): Python Controller, expected a string (sensor name)");
return NULL;
}
@@ -438,21 +438,21 @@ SCA_PythonController::PyGetSensor(PyObject* value)
}
}
PyErr_Format(PyExc_AttributeError, "Unable to find requested sensor \"%s\"", scriptArg);
PyErr_Format(PyExc_AttributeError, "controller.getSensor(string): Python Controller, unable to find requested sensor \"%s\"", scriptArg);
return NULL;
}
const char SCA_PythonController::GetActuator_doc[] =
"GetActuator (char sensorname) return linked actuator that is named [actuatorname]\n";
"getActuator (char sensorname) return linked actuator that is named [actuatorname]\n";
PyObject*
SCA_PythonController::PyGetActuator(PyObject* value)
{
char *scriptArg = PyString_AsString(value);
if (scriptArg==NULL) {
PyErr_SetString(PyExc_TypeError, "expected a string (actuator name)");
PyErr_SetString(PyExc_TypeError, "controller.getActuator(string): Python Controller, expected a string (actuator name)");
return NULL;
}
@@ -465,7 +465,7 @@ SCA_PythonController::PyGetActuator(PyObject* value)
}
}
PyErr_Format(PyExc_AttributeError, "Unable to find requested actuator \"%s\"", scriptArg);
PyErr_Format(PyExc_AttributeError, "controller.getActuator(string): Python Controller, unable to find requested actuator \"%s\"", scriptArg);
return NULL;
}
@@ -536,7 +536,7 @@ int SCA_PythonController::pyattr_set_script(void *self_v, const KX_PYATTRIBUTE_D
char *scriptArg = PyString_AsString(value);
if (scriptArg==NULL) {
PyErr_SetString(PyExc_TypeError, "expected a string (script name)");
PyErr_SetString(PyExc_TypeError, "controller.script = string: Python Controller, expected a string script text");
return -1;
}

2
source/gameengine/GameLogic/SCA_RandomActuator.cpp
View File

@@ -386,7 +386,7 @@ int SCA_RandomActuator::pyattr_set_seed(void *self, const struct KX_PYATTRIBUTE_
act->m_base->SetSeed(ival);
return 0;
} else {
PyErr_SetString(PyExc_TypeError, "expected an integer");
PyErr_SetString(PyExc_TypeError, "actuator.seed = int: Random Actuator, expected an integer");
return 1;
}
}

2
source/gameengine/GameLogic/SCA_RandomSensor.cpp
View File

@@ -224,7 +224,7 @@ int SCA_RandomSensor::pyattr_set_seed(void *self_v, const KX_PYATTRIBUTE_DEF *at
{
SCA_RandomSensor* self= static_cast<SCA_RandomSensor*>(self_v);
if (!PyInt_Check(value)) {
PyErr_SetString(PyExc_TypeError, "expected an integer");
PyErr_SetString(PyExc_TypeError, "sensor.seed = int: Random Sensor, expected an integer");
return -1;
}
self->m_basegenerator->SetSeed(PyInt_AsLong(value));

249
source/gameengine/Ketsji/BL_Shader.cpp
View File

@@ -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))
{
int loc = GetUniformLocation(uniform);
if(loc != -1)
{
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]};
#ifdef SORT_UNIFORMS
SetUniformiv(loc, BL_Uniform::UNI_INT2, array2, sizeof(int)*2);
#else
SetUniform(loc, array2, 2);
#endif
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);
#else
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] };
#ifdef SORT_UNIFORMS
SetUniformiv(loc, BL_Uniform::UNI_INT4, array4, sizeof(int)*4);
#else
SetUniform(loc, array4, 4);
#endif
Py_RETURN_NONE;
}break;
default:
{
PyErr_Format(PyExc_TypeError, "Invalid list size");
return NULL;
}break;
}
}
}
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;
}
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++)
{
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:
{
int array2[2] = { array_data[0],array_data[1]};
#ifdef SORT_UNIFORMS
SetUniformiv(loc, BL_Uniform::UNI_INT2, array2, sizeof(int)*2);
#else
SetUniform(loc, array2, 2);
#endif
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);
#else
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] };
#ifdef SORT_UNIFORMS
SetUniformiv(loc, BL_Uniform::UNI_INT4, array4, sizeof(int)*4);
#else
SetUniform(loc, array4, 4);
#endif
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;
}
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))
{
#ifdef SORT_UNIFORMS
mat.getValue(matr);
SetUniformfv(loc, BL_Uniform::UNI_MAT4, matr, (sizeof(float)*16), (transp!=0) );
#else
SetUniform(loc,mat,(transp!=0));
#endif
Py_RETURN_NONE;
}
}
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;
}
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) );
#else
SetUniform(loc,mat,(transp!=0));
#endif
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))
{
#ifdef SORT_UNIFORMS
mat.getValue(matr);
SetUniformfv(loc, BL_Uniform::UNI_MAT3, matr, (sizeof(float)*9), (transp!=0) );
#else
SetUniform(loc,mat,(transp!=0));
#endif
Py_RETURN_NONE;
}
}
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;
}
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) );
#else
SetUniform(loc,mat,(transp!=0));
#endif
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;
}

2
source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp
View File

@@ -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;
}

4
source/gameengine/Ketsji/KX_BlenderMaterial.cpp
View File

@@ -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;

18
source/gameengine/Ketsji/KX_Camera.cpp
View File

@@ -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;
}

2
source/gameengine/Ketsji/KX_ConstraintActuator.cpp
View File

@@ -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;

46
source/gameengine/Ketsji/KX_GameObject.cpp
View File

@@ -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;
}
}

4
source/gameengine/Ketsji/KX_MeshProxy.cpp
View File

@@ -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;
}

2
source/gameengine/Ketsji/KX_PolyProxy.cpp
View File

@@ -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())

31
source/gameengine/Ketsji/KX_PyMath.h
View File

@@ -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;

32
source/gameengine/Ketsji/KX_PythonInit.cpp
View File

@@ -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;

4
source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp
View File

@@ -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;

4
source/gameengine/Ketsji/KX_Scene.cpp
View File

@@ -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;
}
}

4
source/gameengine/Ketsji/KX_SoundActuator.cpp
View File

@@ -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;
}

3
source/gameengine/Ketsji/KX_TouchSensor.cpp
View File

@@ -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()) {

2
source/gameengine/Ketsji/KX_VertexProxy.cpp
View File

@@ -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;
}

21
source/gameengine/VideoTexture/FilterNormal.cpp
View File

@@ -74,7 +74,7 @@ static int setColor (PyFilter * self, PyObject * value, void * closure)
// check validity of parameter
if (value == NULL || !PyInt_Check(value))
{
PyErr_SetString(PyExc_TypeError, "The value must be a int");
PyErr_SetString(PyExc_TypeError, "filt.colorIdx = int: VideoTexture.FilterNormal, expected the value must be a int");
return -1;
}
// set color index
@@ -94,15 +94,20 @@ static PyObject * getDepth (PyFilter * self, void * closure)
static int setDepth (PyFilter * self, PyObject * value, void * closure)
{
// check validity of parameter
if (value == NULL || !PyFloat_Check(value))
if (value)
{
PyErr_SetString(PyExc_TypeError, "The value must be a float");
return -1;
float depth= (float)PyFloat_AsDouble(value);
if ((depth==-1 && PyErr_Occurred()) == 0) /* no error converting to a float? */
{
// set depth
getFilter(self)->setDepth(depth);
// success
return 0;
}
}
// set depth
getFilter(self)->setDepth(float(PyFloat_AsDouble(value)));
// success
return 0;
PyErr_SetString(PyExc_TypeError, "filt.depth = float: VideoTexture.FilterNormal, expected the value must be a float");
return -1;
}

10
source/gameengine/VideoTexture/blendVideoTex.cpp
View File

@@ -1,6 +1,6 @@
/* $Id$
-----------------------------------------------------------------------------
This source file is part of VideoTexure library
This source file is part of VideoTexture library
Copyright (c) 2006 The Zdeno Ash Miklas
@@ -49,14 +49,14 @@ static PyObject * getMaterialID (PyObject *self, PyObject *args)
char * matName;
// get parameters
if (!PyArg_ParseTuple(args, "Os", &obj, &matName))
if (!PyArg_ParseTuple(args, "Os:materialID", &obj, &matName))
return NULL;
// get material id
short matID = getMaterialID(obj, matName);
// if material was not found, report errot
if (matID < 0)
{
PyErr_SetString(PyExc_RuntimeError, "object doesn't have material with given name");
PyErr_SetString(PyExc_RuntimeError, "VideoTexture.materialID(ob, string): Object doesn't have material with given name");
return NULL;
}
// return material ID
@@ -67,7 +67,7 @@ static PyObject * getMaterialID (PyObject *self, PyObject *args)
// get last error description
static PyObject * getLastError (PyObject *self, PyObject *args)
{
return Py_BuildValue("s", Exception::m_lastError.c_str());
return PyString_FromString(Exception::m_lastError.c_str());
}
// set log file
@@ -89,7 +89,7 @@ static PyObject * imageToArray (PyObject * self, PyObject *args)
if (!PyArg_ParseTuple(args, "O", &pyImg) || !pyImageTypes.in(pyImg->ob_type))
{
// if object is incorect, report error
PyErr_SetString(PyExc_TypeError, "The value must be a image source object");
PyErr_SetString(PyExc_TypeError, "VideoTexture.imageToArray(image): The value must be a image source object");
return NULL;
}
// get image structure