BGE Python API
* fixed segfaults in CListValue.index(val) and CListValue.count(val) when the pyTypes could not be converted into a CValue. * added scene.objects to replace scene.getObjectList() * added function names to PyArg_ParseTuple() so errors will include the function names * removed cases of PyArg_ParseTuple(args,"O",&pyobj) where METH_O ensures a single argument. * Made PyObjectFrom use ugly python api rather then Py_BuildValue(), approx %40 speedup for functions that return Python vector and matrix types like ob.orientation.
This commit is contained in:
Campbell Barton
parent
1c088b454d
commit
5488175d0b
@ -224,10 +224,10 @@ PyParentObject CListValue::Parents[] = {
|
||||
|
||||
|
||||
PyMethodDef CListValue::Methods[] = {
|
||||
{"append", (PyCFunction)CListValue::sPyappend,METH_VARARGS},
|
||||
{"reverse", (PyCFunction)CListValue::sPyreverse,METH_VARARGS},
|
||||
{"index", (PyCFunction)CListValue::sPyindex,METH_VARARGS},
|
||||
{"count", (PyCFunction)CListValue::sPycount,METH_VARARGS},
|
||||
{"append", (PyCFunction)CListValue::sPyappend,METH_O},
|
||||
{"reverse", (PyCFunction)CListValue::sPyreverse,METH_NOARGS},
|
||||
{"index", (PyCFunction)CListValue::sPyindex,METH_O},
|
||||
{"count", (PyCFunction)CListValue::sPycount,METH_O},
|
||||
|
||||
{NULL,NULL} //Sentinel
|
||||
};
|
||||
@ -403,34 +403,17 @@ void CListValue::MergeList(CListValue *otherlist)
|
||||
|
||||
|
||||
|
||||
PyObject* CListValue::Pyappend(PyObject* self,
|
||||
PyObject* args,
|
||||
PyObject* kwds)
|
||||
PyObject* CListValue::Pyappend(PyObject* self, PyObject* value)
|
||||
{
|
||||
|
||||
PyObject* pyobj = NULL;
|
||||
if (PyArg_ParseTuple(args,"O",&pyobj))
|
||||
{
|
||||
return listvalue_buffer_concat(self,pyobj);
|
||||
}
|
||||
else
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
return listvalue_buffer_concat(self, value);
|
||||
}
|
||||
|
||||
|
||||
|
||||
PyObject* CListValue::Pyreverse(PyObject* self,
|
||||
PyObject* args,
|
||||
PyObject* kwds)
|
||||
PyObject* CListValue::Pyreverse(PyObject* self)
|
||||
{
|
||||
std::reverse(m_pValueArray.begin(),m_pValueArray.end());
|
||||
|
||||
Py_RETURN_NONE;
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -452,17 +435,14 @@ bool CListValue::CheckEqual(CValue* first,CValue* second)
|
||||
|
||||
|
||||
|
||||
PyObject* CListValue::Pyindex(PyObject* self,
|
||||
PyObject* args,
|
||||
PyObject* kwds)
|
||||
PyObject* CListValue::Pyindex(PyObject* self, PyObject *value)
|
||||
{
|
||||
PyObject* result = NULL;
|
||||
|
||||
PyObject* pyobj = NULL;
|
||||
if (PyArg_ParseTuple(args,"O",&pyobj))
|
||||
{
|
||||
CValue* checkobj = ConvertPythonToValue(value);
|
||||
if (checkobj==NULL)
|
||||
return NULL; /* ConvertPythonToValue sets the error */
|
||||
|
||||
CValue* checkobj = ConvertPythonToValue(pyobj);
|
||||
int numelem = GetCount();
|
||||
for (int i=0;i<numelem;i++)
|
||||
{
|
||||
@ -474,25 +454,27 @@ PyObject* CListValue::Pyindex(PyObject* self,
|
||||
}
|
||||
}
|
||||
checkobj->Release();
|
||||
}
|
||||
|
||||
if (result==NULL) {
|
||||
PyErr_SetString(PyExc_ValueError, "ValueError: list.index(x): x not in CListValue");
|
||||
}
|
||||
return result;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
PyObject* CListValue::Pycount(PyObject* self,
|
||||
PyObject* args,
|
||||
PyObject* kwds)
|
||||
PyObject* CListValue::Pycount(PyObject* self, PyObject* value)
|
||||
{
|
||||
|
||||
int numfound = 0;
|
||||
|
||||
PyObject* pyobj = NULL;
|
||||
if (PyArg_ParseTuple(args,"O",&pyobj))
|
||||
{
|
||||
CValue* checkobj = ConvertPythonToValue(pyobj);
|
||||
CValue* checkobj = ConvertPythonToValue(value);
|
||||
|
||||
if (checkobj==NULL) { /* in this case just return that there are no items in the list */
|
||||
PyErr_Clear();
|
||||
PyInt_FromLong(0);
|
||||
}
|
||||
|
||||
int numelem = GetCount();
|
||||
for (int i=0;i<numelem;i++)
|
||||
{
|
||||
@ -503,7 +485,6 @@ PyObject* CListValue::Pycount(PyObject* self,
|
||||
}
|
||||
}
|
||||
checkobj->Release();
|
||||
}
|
||||
|
||||
return PyInt_FromLong(numfound);
|
||||
}
|
||||
|
||||
@ -61,10 +61,10 @@ public:
|
||||
|
||||
virtual PyObject* _getattr(const char *attr);
|
||||
|
||||
KX_PYMETHOD(CListValue,append);
|
||||
KX_PYMETHOD(CListValue,reverse);
|
||||
KX_PYMETHOD(CListValue,index);
|
||||
KX_PYMETHOD(CListValue,count);
|
||||
KX_PYMETHOD_O(CListValue,append);
|
||||
KX_PYMETHOD_NOARGS(CListValue,reverse);
|
||||
KX_PYMETHOD_O(CListValue,index);
|
||||
KX_PYMETHOD_O(CListValue,count);
|
||||
|
||||
|
||||
private:
|
||||
|
||||
@ -470,15 +470,15 @@ int KX_Camera::GetViewportTop() const
|
||||
|
||||
PyMethodDef KX_Camera::Methods[] = {
|
||||
KX_PYMETHODTABLE(KX_Camera, sphereInsideFrustum),
|
||||
KX_PYMETHODTABLE(KX_Camera, boxInsideFrustum),
|
||||
KX_PYMETHODTABLE(KX_Camera, pointInsideFrustum),
|
||||
KX_PYMETHODTABLE(KX_Camera, getCameraToWorld),
|
||||
KX_PYMETHODTABLE(KX_Camera, getWorldToCamera),
|
||||
KX_PYMETHODTABLE(KX_Camera, getProjectionMatrix),
|
||||
KX_PYMETHODTABLE(KX_Camera, setProjectionMatrix),
|
||||
KX_PYMETHODTABLE(KX_Camera, enableViewport),
|
||||
KX_PYMETHODTABLE_O(KX_Camera, boxInsideFrustum),
|
||||
KX_PYMETHODTABLE_O(KX_Camera, pointInsideFrustum),
|
||||
KX_PYMETHODTABLE_NOARGS(KX_Camera, getCameraToWorld),
|
||||
KX_PYMETHODTABLE_NOARGS(KX_Camera, getWorldToCamera),
|
||||
KX_PYMETHODTABLE_NOARGS(KX_Camera, getProjectionMatrix),
|
||||
KX_PYMETHODTABLE_O(KX_Camera, setProjectionMatrix),
|
||||
KX_PYMETHODTABLE_O(KX_Camera, enableViewport),
|
||||
KX_PYMETHODTABLE(KX_Camera, setViewport),
|
||||
KX_PYMETHODTABLE(KX_Camera, setOnTop),
|
||||
KX_PYMETHODTABLE_NOARGS(KX_Camera, setOnTop),
|
||||
|
||||
{NULL,NULL} //Sentinel
|
||||
};
|
||||
@ -624,7 +624,7 @@ int KX_Camera::_setattr(const char *attr, PyObject *pyvalue)
|
||||
return KX_GameObject::_setattr(attr, pyvalue);
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, sphereInsideFrustum,
|
||||
KX_PYMETHODDEF_DOC_VARARGS(KX_Camera, sphereInsideFrustum,
|
||||
"sphereInsideFrustum(center, radius) -> Integer\n"
|
||||
"\treturns INSIDE, OUTSIDE or INTERSECT if the given sphere is\n"
|
||||
"\tinside/outside/intersects this camera's viewing frustum.\n\n"
|
||||
@ -658,7 +658,7 @@ KX_PYMETHODDEF_DOC(KX_Camera, sphereInsideFrustum,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, boxInsideFrustum,
|
||||
KX_PYMETHODDEF_DOC_O(KX_Camera, boxInsideFrustum,
|
||||
"boxInsideFrustum(box) -> Integer\n"
|
||||
"\treturns INSIDE, OUTSIDE or INTERSECT if the given box is\n"
|
||||
"\tinside/outside/intersects this camera's viewing frustum.\n\n"
|
||||
@ -683,10 +683,7 @@ KX_PYMETHODDEF_DOC(KX_Camera, boxInsideFrustum,
|
||||
"\t\t# Box is outside the frustum !\n"
|
||||
)
|
||||
{
|
||||
PyObject *pybox;
|
||||
if (PyArg_ParseTuple(args, "O", &pybox))
|
||||
{
|
||||
unsigned int num_points = PySequence_Size(pybox);
|
||||
unsigned int num_points = PySequence_Size(value);
|
||||
if (num_points != 8)
|
||||
{
|
||||
PyErr_Format(PyExc_TypeError, "boxInsideFrustum: Expected eight (8) points, got %d", num_points);
|
||||
@ -696,7 +693,7 @@ KX_PYMETHODDEF_DOC(KX_Camera, boxInsideFrustum,
|
||||
MT_Point3 box[8];
|
||||
for (unsigned int p = 0; p < 8 ; p++)
|
||||
{
|
||||
PyObject *item = PySequence_GetItem(pybox, p); /* new ref */
|
||||
PyObject *item = PySequence_GetItem(value, p); /* new ref */
|
||||
bool error = !PyVecTo(item, box[p]);
|
||||
Py_DECREF(item);
|
||||
if (error)
|
||||
@ -704,13 +701,9 @@ KX_PYMETHODDEF_DOC(KX_Camera, boxInsideFrustum,
|
||||
}
|
||||
|
||||
return PyInt_FromLong(BoxInsideFrustum(box)); /* new ref */
|
||||
}
|
||||
|
||||
PyErr_SetString(PyExc_TypeError, "boxInsideFrustum: Expected argument: list of points.");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, pointInsideFrustum,
|
||||
KX_PYMETHODDEF_DOC_O(KX_Camera, pointInsideFrustum,
|
||||
"pointInsideFrustum(point) -> Bool\n"
|
||||
"\treturns 1 if the given point is inside this camera's viewing frustum.\n\n"
|
||||
"\tpoint = The point to test (in world coordinates.)\n\n"
|
||||
@ -727,7 +720,7 @@ KX_PYMETHODDEF_DOC(KX_Camera, pointInsideFrustum,
|
||||
)
|
||||
{
|
||||
MT_Point3 point;
|
||||
if (PyVecArgTo(args, point))
|
||||
if (PyVecTo(value, point))
|
||||
{
|
||||
return PyInt_FromLong(PointInsideFrustum(point)); /* new ref */
|
||||
}
|
||||
@ -736,7 +729,7 @@ KX_PYMETHODDEF_DOC(KX_Camera, pointInsideFrustum,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, getCameraToWorld,
|
||||
KX_PYMETHODDEF_DOC_NOARGS(KX_Camera, getCameraToWorld,
|
||||
"getCameraToWorld() -> Matrix4x4\n"
|
||||
"\treturns the camera to world transformation matrix, as a list of four lists of four values.\n\n"
|
||||
"\tie: [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]])\n"
|
||||
@ -745,7 +738,7 @@ KX_PYMETHODDEF_DOC(KX_Camera, getCameraToWorld,
|
||||
return PyObjectFrom(GetCameraToWorld()); /* new ref */
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, getWorldToCamera,
|
||||
KX_PYMETHODDEF_DOC_NOARGS(KX_Camera, getWorldToCamera,
|
||||
"getWorldToCamera() -> Matrix4x4\n"
|
||||
"\treturns the world to camera transformation matrix, as a list of four lists of four values.\n\n"
|
||||
"\tie: [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]])\n"
|
||||
@ -754,7 +747,7 @@ KX_PYMETHODDEF_DOC(KX_Camera, getWorldToCamera,
|
||||
return PyObjectFrom(GetWorldToCamera()); /* new ref */
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, getProjectionMatrix,
|
||||
KX_PYMETHODDEF_DOC_NOARGS(KX_Camera, getProjectionMatrix,
|
||||
"getProjectionMatrix() -> Matrix4x4\n"
|
||||
"\treturns this camera's projection matrix, as a list of four lists of four values.\n\n"
|
||||
"\tie: [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]])\n"
|
||||
@ -763,7 +756,7 @@ KX_PYMETHODDEF_DOC(KX_Camera, getProjectionMatrix,
|
||||
return PyObjectFrom(GetProjectionMatrix()); /* new ref */
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, setProjectionMatrix,
|
||||
KX_PYMETHODDEF_DOC_O(KX_Camera, setProjectionMatrix,
|
||||
"setProjectionMatrix(MT_Matrix4x4 m) -> None\n"
|
||||
"\tSets this camera's projection matrix\n"
|
||||
"\n"
|
||||
@ -805,56 +798,50 @@ KX_PYMETHODDEF_DOC(KX_Camera, setProjectionMatrix,
|
||||
"\tcam = co.getOwner()\n"
|
||||
"\tcam.setProjectionMatrix(Perspective(-1.0, 1.0, -1.0, 1.0, 0.1, 1))\n")
|
||||
{
|
||||
PyObject *pymat;
|
||||
if (PyArg_ParseTuple(args, "O", &pymat))
|
||||
{
|
||||
MT_Matrix4x4 mat;
|
||||
if (PyMatTo(pymat, mat))
|
||||
if (!PyMatTo(value, mat))
|
||||
{
|
||||
SetProjectionMatrix(mat);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
PyErr_SetString(PyExc_TypeError, "setProjectionMatrix: Expected 4x4 list as matrix argument.");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SetProjectionMatrix(mat);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, enableViewport,
|
||||
KX_PYMETHODDEF_DOC_O(KX_Camera, enableViewport,
|
||||
"enableViewport(viewport)\n"
|
||||
"Sets this camera's viewport status\n"
|
||||
)
|
||||
{
|
||||
int viewport;
|
||||
if (PyArg_ParseTuple(args,"i",&viewport))
|
||||
{
|
||||
int viewport = PyObject_IsTrue(value);
|
||||
|
||||
if (viewport == -1) {
|
||||
PyErr_SetString(PyExc_ValueError, "expected True/False or 0/1");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if(viewport)
|
||||
EnableViewport(true);
|
||||
else
|
||||
EnableViewport(false);
|
||||
}
|
||||
else {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, setViewport,
|
||||
KX_PYMETHODDEF_DOC_VARARGS(KX_Camera, setViewport,
|
||||
"setViewport(left, bottom, right, top)\n"
|
||||
"Sets this camera's viewport\n")
|
||||
{
|
||||
int left, bottom, right, top;
|
||||
if (PyArg_ParseTuple(args,"iiii",&left, &bottom, &right, &top))
|
||||
{
|
||||
SetViewport(left, bottom, right, top);
|
||||
} else {
|
||||
if (!PyArg_ParseTuple(args,"iiii:setViewport",&left, &bottom, &right, &top))
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SetViewport(left, bottom, right, top);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Camera, setOnTop,
|
||||
KX_PYMETHODDEF_DOC_NOARGS(KX_Camera, setOnTop,
|
||||
"setOnTop()\n"
|
||||
"Sets this camera's viewport on top\n")
|
||||
{
|
||||
|
||||
@ -257,18 +257,18 @@ public:
|
||||
int GetViewportTop() const;
|
||||
|
||||
|
||||
KX_PYMETHOD_DOC(KX_Camera, sphereInsideFrustum);
|
||||
KX_PYMETHOD_DOC(KX_Camera, boxInsideFrustum);
|
||||
KX_PYMETHOD_DOC(KX_Camera, pointInsideFrustum);
|
||||
KX_PYMETHOD_DOC_VARARGS(KX_Camera, sphereInsideFrustum);
|
||||
KX_PYMETHOD_DOC_O(KX_Camera, boxInsideFrustum);
|
||||
KX_PYMETHOD_DOC_O(KX_Camera, pointInsideFrustum);
|
||||
|
||||
KX_PYMETHOD_DOC(KX_Camera, getCameraToWorld);
|
||||
KX_PYMETHOD_DOC(KX_Camera, getWorldToCamera);
|
||||
KX_PYMETHOD_DOC(KX_Camera, getProjectionMatrix);
|
||||
KX_PYMETHOD_DOC(KX_Camera, setProjectionMatrix);
|
||||
KX_PYMETHOD_DOC_NOARGS(KX_Camera, getCameraToWorld);
|
||||
KX_PYMETHOD_DOC_NOARGS(KX_Camera, getWorldToCamera);
|
||||
KX_PYMETHOD_DOC_NOARGS(KX_Camera, getProjectionMatrix);
|
||||
KX_PYMETHOD_DOC_O(KX_Camera, setProjectionMatrix);
|
||||
|
||||
KX_PYMETHOD_DOC(KX_Camera, enableViewport);
|
||||
KX_PYMETHOD_DOC(KX_Camera, setViewport);
|
||||
KX_PYMETHOD_DOC(KX_Camera, setOnTop);
|
||||
KX_PYMETHOD_DOC_O(KX_Camera, enableViewport);
|
||||
KX_PYMETHOD_DOC_VARARGS(KX_Camera, setViewport);
|
||||
KX_PYMETHOD_DOC_NOARGS(KX_Camera, setOnTop);
|
||||
|
||||
virtual PyObject* _getattr(const char *attr); /* lens, near, far, projection_matrix */
|
||||
virtual int _setattr(const char *attr, PyObject *pyvalue);
|
||||
|
||||
@ -1030,8 +1030,8 @@ PyMethodDef KX_GameObject::Methods[] = {
|
||||
{"endObject",(PyCFunction) KX_GameObject::sPyEndObject, METH_NOARGS},
|
||||
KX_PYMETHODTABLE(KX_GameObject, rayCastTo),
|
||||
KX_PYMETHODTABLE(KX_GameObject, rayCast),
|
||||
KX_PYMETHODTABLE(KX_GameObject, getDistanceTo),
|
||||
KX_PYMETHODTABLE(KX_GameObject, getVectTo),
|
||||
KX_PYMETHODTABLE_O(KX_GameObject, getDistanceTo),
|
||||
KX_PYMETHODTABLE_O(KX_GameObject, getVectTo),
|
||||
{NULL,NULL} //Sentinel
|
||||
};
|
||||
|
||||
@ -1136,10 +1136,7 @@ PyObject* KX_GameObject::_getattr(const char *attr)
|
||||
{
|
||||
KX_GameObject* parent = GetParent();
|
||||
if (parent)
|
||||
{
|
||||
parent->AddRef();
|
||||
return parent;
|
||||
}
|
||||
return parent->AddRef();
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
@ -1297,7 +1294,7 @@ PyObject* KX_GameObject::PyApplyForce(PyObject* self, PyObject* args)
|
||||
int local = 0;
|
||||
PyObject* pyvect;
|
||||
|
||||
if (PyArg_ParseTuple(args, "O|i", &pyvect, &local)) {
|
||||
if (PyArg_ParseTuple(args, "O|i:applyForce", &pyvect, &local)) {
|
||||
MT_Vector3 force;
|
||||
if (PyVecTo(pyvect, force)) {
|
||||
ApplyForce(force, (local!=0));
|
||||
@ -1312,7 +1309,7 @@ PyObject* KX_GameObject::PyApplyTorque(PyObject* self, PyObject* args)
|
||||
int local = 0;
|
||||
PyObject* pyvect;
|
||||
|
||||
if (PyArg_ParseTuple(args, "O|i", &pyvect, &local)) {
|
||||
if (PyArg_ParseTuple(args, "O|i:applyTorque", &pyvect, &local)) {
|
||||
MT_Vector3 torque;
|
||||
if (PyVecTo(pyvect, torque)) {
|
||||
ApplyTorque(torque, (local!=0));
|
||||
@ -1327,7 +1324,7 @@ PyObject* KX_GameObject::PyApplyRotation(PyObject* self, PyObject* args)
|
||||
int local = 0;
|
||||
PyObject* pyvect;
|
||||
|
||||
if (PyArg_ParseTuple(args, "O|i", &pyvect, &local)) {
|
||||
if (PyArg_ParseTuple(args, "O|i:applyRotation", &pyvect, &local)) {
|
||||
MT_Vector3 rotation;
|
||||
if (PyVecTo(pyvect, rotation)) {
|
||||
ApplyRotation(rotation, (local!=0));
|
||||
@ -1342,7 +1339,7 @@ PyObject* KX_GameObject::PyApplyMovement(PyObject* self, PyObject* args)
|
||||
int local = 0;
|
||||
PyObject* pyvect;
|
||||
|
||||
if (PyArg_ParseTuple(args, "O|i", &pyvect, &local)) {
|
||||
if (PyArg_ParseTuple(args, "O|i:applyMovement", &pyvect, &local)) {
|
||||
MT_Vector3 movement;
|
||||
if (PyVecTo(pyvect, movement)) {
|
||||
ApplyMovement(movement, (local!=0));
|
||||
@ -1356,7 +1353,7 @@ PyObject* KX_GameObject::PyGetLinearVelocity(PyObject* self, PyObject* args)
|
||||
{
|
||||
// only can get the velocity if we have a physics object connected to us...
|
||||
int local = 0;
|
||||
if (PyArg_ParseTuple(args,"|i",&local))
|
||||
if (PyArg_ParseTuple(args,"|i:getLinearVelocity",&local))
|
||||
{
|
||||
return PyObjectFrom(GetLinearVelocity((local!=0)));
|
||||
}
|
||||
@ -1371,7 +1368,7 @@ PyObject* KX_GameObject::PySetLinearVelocity(PyObject* self, PyObject* args)
|
||||
int local = 0;
|
||||
PyObject* pyvect;
|
||||
|
||||
if (PyArg_ParseTuple(args,"O|i",&pyvect,&local)) {
|
||||
if (PyArg_ParseTuple(args,"O|i:setLinearVelocity",&pyvect,&local)) {
|
||||
MT_Vector3 velocity;
|
||||
if (PyVecTo(pyvect, velocity)) {
|
||||
setLinearVelocity(velocity, (local!=0));
|
||||
@ -1385,7 +1382,7 @@ PyObject* KX_GameObject::PyGetAngularVelocity(PyObject* self, PyObject* args)
|
||||
{
|
||||
// only can get the velocity if we have a physics object connected to us...
|
||||
int local = 0;
|
||||
if (PyArg_ParseTuple(args,"|i",&local))
|
||||
if (PyArg_ParseTuple(args,"|i:getAngularVelocity",&local))
|
||||
{
|
||||
return PyObjectFrom(GetAngularVelocity((local!=0)));
|
||||
}
|
||||
@ -1400,7 +1397,7 @@ PyObject* KX_GameObject::PySetAngularVelocity(PyObject* self, PyObject* args)
|
||||
int local = 0;
|
||||
PyObject* pyvect;
|
||||
|
||||
if (PyArg_ParseTuple(args,"O|i",&pyvect,&local)) {
|
||||
if (PyArg_ParseTuple(args,"O|i:setAngularVelocity",&pyvect,&local)) {
|
||||
MT_Vector3 velocity;
|
||||
if (PyVecTo(pyvect, velocity)) {
|
||||
setAngularVelocity(velocity, (local!=0));
|
||||
@ -1413,7 +1410,7 @@ PyObject* KX_GameObject::PySetAngularVelocity(PyObject* self, PyObject* args)
|
||||
PyObject* KX_GameObject::PySetVisible(PyObject* self, PyObject* args)
|
||||
{
|
||||
int visible, recursive = 0;
|
||||
if (!PyArg_ParseTuple(args,"i|i",&visible, &recursive))
|
||||
if (!PyArg_ParseTuple(args,"i|i:setVisible",&visible, &recursive))
|
||||
return NULL;
|
||||
|
||||
SetVisible(visible ? true:false, recursive ? true:false);
|
||||
@ -1464,7 +1461,7 @@ PyObject* KX_GameObject::PyGetVelocity(PyObject* self, PyObject* args)
|
||||
|
||||
|
||||
PyObject* pypos = NULL;
|
||||
if (PyArg_ParseTuple(args, "|O", &pypos))
|
||||
if (PyArg_ParseTuple(args, "|O:getVelocity", &pypos))
|
||||
{
|
||||
if (pypos)
|
||||
PyVecTo(pypos, point);
|
||||
@ -1520,10 +1517,7 @@ PyObject* KX_GameObject::PyGetParent(PyObject* self)
|
||||
{
|
||||
KX_GameObject* parent = this->GetParent();
|
||||
if (parent)
|
||||
{
|
||||
parent->AddRef();
|
||||
return parent;
|
||||
}
|
||||
return parent->AddRef();
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
@ -1592,7 +1586,7 @@ PyObject* KX_GameObject::PyGetMesh(PyObject* self, PyObject* args)
|
||||
{
|
||||
int mesh = 0;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|i", &mesh))
|
||||
if (!PyArg_ParseTuple(args, "|i:getMesh", &mesh))
|
||||
return NULL; // python sets a simple error
|
||||
|
||||
if (((unsigned int)mesh < m_meshes.size()) && mesh >= 0)
|
||||
@ -1638,7 +1632,7 @@ PyObject* KX_GameObject::PyApplyImpulse(PyObject* self, PyObject* args)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (PyArg_ParseTuple(args, "OO", &pyattach, &pyimpulse))
|
||||
if (PyArg_ParseTuple(args, "OO:applyImpulse", &pyattach, &pyimpulse))
|
||||
{
|
||||
MT_Point3 attach;
|
||||
MT_Vector3 impulse;
|
||||
@ -1705,7 +1699,7 @@ PyObject* KX_GameObject::PyAlignAxisToVect(PyObject* self, PyObject* args)
|
||||
int axis = 2; //z axis is the default
|
||||
float fac = 1.0;
|
||||
|
||||
if (PyArg_ParseTuple(args,"O|if",&pyvect,&axis, &fac))
|
||||
if (PyArg_ParseTuple(args,"O|if:alignAxisToVect",&pyvect,&axis, &fac))
|
||||
{
|
||||
MT_Vector3 vect;
|
||||
if (PyVecTo(pyvect, vect))
|
||||
@ -1773,19 +1767,18 @@ PyObject* KX_GameObject::PyGetPropertyNames(PyObject* self)
|
||||
return ConvertKeysToPython();
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_GameObject, getDistanceTo,
|
||||
KX_PYMETHODDEF_DOC_O(KX_GameObject, getDistanceTo,
|
||||
"getDistanceTo(other): get distance to another point/KX_GameObject")
|
||||
{
|
||||
MT_Point3 b;
|
||||
if (PyVecArgTo(args, b))
|
||||
if (PyVecTo(value, b))
|
||||
{
|
||||
return PyFloat_FromDouble(NodeGetWorldPosition().distance(b));
|
||||
}
|
||||
PyErr_Clear();
|
||||
|
||||
PyObject *pyother;
|
||||
KX_GameObject *other;
|
||||
if (PyArg_ParseTuple(args, "O", &pyother) && ConvertPythonToGameObject(pyother, &other, false))
|
||||
if (ConvertPythonToGameObject(value, &other, false))
|
||||
{
|
||||
return PyFloat_FromDouble(NodeGetWorldPosition().distance(other->NodeGetWorldPosition()));
|
||||
}
|
||||
@ -1793,7 +1786,7 @@ KX_PYMETHODDEF_DOC(KX_GameObject, getDistanceTo,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_GameObject, getVectTo,
|
||||
KX_PYMETHODDEF_DOC_O(KX_GameObject, getVectTo,
|
||||
"getVectTo(other): get vector and the distance to another point/KX_GameObject\n"
|
||||
"Returns a 3-tuple with (distance,worldVector,localVector)\n")
|
||||
{
|
||||
@ -1802,14 +1795,13 @@ KX_PYMETHODDEF_DOC(KX_GameObject, getVectTo,
|
||||
MT_Scalar distance;
|
||||
|
||||
PyObject *returnValue;
|
||||
PyObject *pyother;
|
||||
|
||||
if (!PyVecArgTo(args, toPoint))
|
||||
if (!PyVecTo(value, toPoint))
|
||||
{
|
||||
PyErr_Clear();
|
||||
|
||||
KX_GameObject *other;
|
||||
if (PyArg_ParseTuple(args, "O", &pyother) && ConvertPythonToGameObject(pyother, &other, false))
|
||||
if (ConvertPythonToGameObject(value, &other, false))
|
||||
{
|
||||
toPoint = other->NodeGetWorldPosition();
|
||||
} else
|
||||
@ -1894,7 +1886,7 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCastTo,
|
||||
float dist = 0.0f;
|
||||
char *propName = NULL;
|
||||
|
||||
if (!PyArg_ParseTuple(args,"O|fs", &pyarg, &dist, &propName)) {
|
||||
if (!PyArg_ParseTuple(args,"O|fs:rayCastTo", &pyarg, &dist, &propName)) {
|
||||
return NULL; // python sets simple error
|
||||
}
|
||||
|
||||
@ -1937,10 +1929,8 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCastTo,
|
||||
KX_RayCast::RayTest(pe, fromPoint, toPoint, callback);
|
||||
|
||||
if (m_pHitObject)
|
||||
{
|
||||
m_pHitObject->AddRef();
|
||||
return m_pHitObject;
|
||||
}
|
||||
return m_pHitObject->AddRef();
|
||||
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
@ -1973,7 +1963,7 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,
|
||||
KX_GameObject *other;
|
||||
int face=0, xray=0, poly=0;
|
||||
|
||||
if (!PyArg_ParseTuple(args,"O|Ofsiii", &pyto, &pyfrom, &dist, &propName, &face, &xray, &poly)) {
|
||||
if (!PyArg_ParseTuple(args,"O|Ofsiii:rayCast", &pyto, &pyfrom, &dist, &propName, &face, &xray, &poly)) {
|
||||
return NULL; // Python sets a simple error
|
||||
}
|
||||
|
||||
|
||||
@ -799,8 +799,8 @@ public:
|
||||
KX_PYMETHOD_NOARGS(KX_GameObject,EndObject);
|
||||
KX_PYMETHOD_DOC(KX_GameObject,rayCastTo);
|
||||
KX_PYMETHOD_DOC(KX_GameObject,rayCast);
|
||||
KX_PYMETHOD_DOC(KX_GameObject,getDistanceTo);
|
||||
KX_PYMETHOD_DOC(KX_GameObject,getVectTo);
|
||||
KX_PYMETHOD_DOC_O(KX_GameObject,getDistanceTo);
|
||||
KX_PYMETHOD_DOC_O(KX_GameObject,getVectTo);
|
||||
|
||||
private :
|
||||
|
||||
|
||||
@ -77,35 +77,92 @@ bool PyObject_IsMT_Matrix(PyObject *pymat, unsigned int rank)
|
||||
|
||||
PyObject* PyObjectFrom(const MT_Matrix4x4 &mat)
|
||||
{
|
||||
#if 0
|
||||
return Py_BuildValue("[[ffff][ffff][ffff][ffff]]",
|
||||
mat[0][0], mat[0][1], mat[0][2], mat[0][3],
|
||||
mat[1][0], mat[1][1], mat[1][2], mat[1][3],
|
||||
mat[2][0], mat[2][1], mat[2][2], mat[2][3],
|
||||
mat[3][0], mat[3][1], mat[3][2], mat[3][3]);
|
||||
#else
|
||||
PyObject *list = PyList_New(4);
|
||||
PyObject *sublist;
|
||||
int i;
|
||||
|
||||
for(i=0; i < 4; i++) {
|
||||
sublist = PyList_New(4);
|
||||
PyList_SET_ITEM(sublist, 0, PyFloat_FromDouble(mat[i][0]));
|
||||
PyList_SET_ITEM(sublist, 1, PyFloat_FromDouble(mat[i][1]));
|
||||
PyList_SET_ITEM(sublist, 2, PyFloat_FromDouble(mat[i][2]));
|
||||
PyList_SET_ITEM(sublist, 2, PyFloat_FromDouble(mat[i][3]));
|
||||
PyList_SET_ITEM(list, i, sublist);
|
||||
}
|
||||
|
||||
return list;
|
||||
#endif
|
||||
}
|
||||
|
||||
PyObject* PyObjectFrom(const MT_Matrix3x3 &mat)
|
||||
{
|
||||
#if 0
|
||||
return Py_BuildValue("[[fff][fff][fff]]",
|
||||
mat[0][0], mat[0][1], mat[0][2],
|
||||
mat[1][0], mat[1][1], mat[1][2],
|
||||
mat[2][0], mat[2][1], mat[2][2]);
|
||||
#else
|
||||
PyObject *list = PyList_New(3);
|
||||
PyObject *sublist;
|
||||
int i;
|
||||
|
||||
for(i=0; i < 3; i++) {
|
||||
sublist = PyList_New(3);
|
||||
PyList_SET_ITEM(sublist, 0, PyFloat_FromDouble(mat[i][0]));
|
||||
PyList_SET_ITEM(sublist, 1, PyFloat_FromDouble(mat[i][1]));
|
||||
PyList_SET_ITEM(sublist, 2, PyFloat_FromDouble(mat[i][2]));
|
||||
PyList_SET_ITEM(list, i, sublist);
|
||||
}
|
||||
|
||||
return list;
|
||||
#endif
|
||||
}
|
||||
|
||||
PyObject* PyObjectFrom(const MT_Tuple4 &vec)
|
||||
{
|
||||
#if 0
|
||||
return Py_BuildValue("[ffff]",
|
||||
vec[0], vec[1], vec[2], vec[3]);
|
||||
#else
|
||||
PyObject *list = PyList_New(4);
|
||||
PyList_SET_ITEM(list, 0, PyFloat_FromDouble(vec[0]));
|
||||
PyList_SET_ITEM(list, 1, PyFloat_FromDouble(vec[1]));
|
||||
PyList_SET_ITEM(list, 2, PyFloat_FromDouble(vec[2]));
|
||||
PyList_SET_ITEM(list, 3, PyFloat_FromDouble(vec[3]));
|
||||
return list;
|
||||
#endif
|
||||
}
|
||||
|
||||
PyObject* PyObjectFrom(const MT_Tuple3 &vec)
|
||||
{
|
||||
#if 0
|
||||
return Py_BuildValue("[fff]",
|
||||
vec[0], vec[1], vec[2]);
|
||||
#else
|
||||
PyObject *list = PyList_New(3);
|
||||
PyList_SET_ITEM(list, 0, PyFloat_FromDouble(vec[0]));
|
||||
PyList_SET_ITEM(list, 1, PyFloat_FromDouble(vec[1]));
|
||||
PyList_SET_ITEM(list, 2, PyFloat_FromDouble(vec[2]));
|
||||
return list;
|
||||
#endif
|
||||
}
|
||||
|
||||
PyObject* PyObjectFrom(const MT_Tuple2 &vec)
|
||||
{
|
||||
#if 0
|
||||
return Py_BuildValue("[ff]",
|
||||
vec[0], vec[1]);
|
||||
#else
|
||||
PyObject *list = PyList_New(2);
|
||||
PyList_SET_ITEM(list, 0, PyFloat_FromDouble(vec[0]));
|
||||
PyList_SET_ITEM(list, 1, PyFloat_FromDouble(vec[1]));
|
||||
return list;
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -130,20 +130,6 @@ bool PyVecTo(PyObject* pyval, T& vec)
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a python argument to an MT class.
|
||||
* This paramater expects arguments as passed to a python method.
|
||||
*/
|
||||
template<class T>
|
||||
bool PyVecArgTo(PyObject* args, T& vec)
|
||||
{
|
||||
PyObject* pylist;
|
||||
if (PyArg_ParseTuple(args,"O",&pylist))
|
||||
return PyVecTo(pylist, vec);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts an MT_Matrix4x4 to a python object.
|
||||
*/
|
||||
|
||||
@ -125,10 +125,10 @@ static PyObject* gPyGetRandomFloat(PyObject*)
|
||||
return PyFloat_FromDouble(MT_random());
|
||||
}
|
||||
|
||||
static PyObject* gPySetGravity(PyObject*, PyObject* args)
|
||||
static PyObject* gPySetGravity(PyObject*, PyObject* value)
|
||||
{
|
||||
MT_Vector3 vec = MT_Vector3(0., 0., 0.);
|
||||
if (!PyVecArgTo(args, vec))
|
||||
MT_Vector3 vec;
|
||||
if (!PyVecTo(value, vec))
|
||||
return NULL;
|
||||
|
||||
if (gp_KetsjiScene)
|
||||
@ -412,7 +412,7 @@ static struct PyMethodDef game_methods[] = {
|
||||
METH_VARARGS, (PY_METHODCHAR)SCA_PythonController::sPyAddActiveActuator__doc__},
|
||||
{"getRandomFloat",(PyCFunction) gPyGetRandomFloat,
|
||||
METH_NOARGS, (PY_METHODCHAR)gPyGetRandomFloat_doc.Ptr()},
|
||||
{"setGravity",(PyCFunction) gPySetGravity, METH_VARARGS, (PY_METHODCHAR)"set Gravitation"},
|
||||
{"setGravity",(PyCFunction) gPySetGravity, METH_O, (PY_METHODCHAR)"set Gravitation"},
|
||||
{"getSpectrum",(PyCFunction) gPyGetSpectrum, METH_NOARGS, (PY_METHODCHAR)"get audio spectrum"},
|
||||
{"stopDSP",(PyCFunction) gPyStopDSP, METH_VARARGS, (PY_METHODCHAR)"stop using the audio dsp (for performance reasons)"},
|
||||
{"getLogicTicRate", (PyCFunction) gPyGetLogicTicRate, METH_NOARGS, (PY_METHODCHAR)"Gets the logic tic rate"},
|
||||
@ -542,11 +542,11 @@ static PyObject* gPyGetFocalLength(PyObject*, PyObject*, PyObject*)
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
static PyObject* gPySetBackgroundColor(PyObject*, PyObject* args)
|
||||
static PyObject* gPySetBackgroundColor(PyObject*, PyObject* value)
|
||||
{
|
||||
|
||||
MT_Vector4 vec = MT_Vector4(0., 0., 0.3, 0.);
|
||||
if (!PyVecArgTo(args, vec))
|
||||
MT_Vector4 vec;
|
||||
if (!PyVecTo(value, vec))
|
||||
return NULL;
|
||||
|
||||
if (gp_Canvas)
|
||||
@ -558,11 +558,11 @@ static PyObject* gPySetBackgroundColor(PyObject*, PyObject* args)
|
||||
|
||||
|
||||
|
||||
static PyObject* gPySetMistColor(PyObject*, PyObject* args)
|
||||
static PyObject* gPySetMistColor(PyObject*, PyObject* value)
|
||||
{
|
||||
|
||||
MT_Vector3 vec = MT_Vector3(0., 0., 0.);
|
||||
if (!PyVecArgTo(args, vec))
|
||||
MT_Vector3 vec;
|
||||
if (!PyVecTo(value, vec))
|
||||
return NULL;
|
||||
|
||||
if (!gp_Rasterizer) {
|
||||
@ -613,11 +613,11 @@ static PyObject* gPySetMistEnd(PyObject*, PyObject* args)
|
||||
}
|
||||
|
||||
|
||||
static PyObject* gPySetAmbientColor(PyObject*, PyObject* args)
|
||||
static PyObject* gPySetAmbientColor(PyObject*, PyObject* value)
|
||||
{
|
||||
|
||||
MT_Vector3 vec = MT_Vector3(0., 0., 0.);
|
||||
if (!PyVecArgTo(args, vec))
|
||||
MT_Vector3 vec;
|
||||
if (!PyVecTo(value, vec))
|
||||
return NULL;
|
||||
|
||||
if (!gp_Rasterizer) {
|
||||
@ -812,9 +812,9 @@ static PyObject* gPyDrawLine(PyObject*, PyObject* args)
|
||||
if (!PyArg_ParseTuple(args,"OOO",&ob_from,&ob_to,&ob_color))
|
||||
return NULL;
|
||||
|
||||
MT_Vector3 from(0., 0., 0.);
|
||||
MT_Vector3 to(0., 0., 0.);
|
||||
MT_Vector3 color(0., 0., 0.);
|
||||
MT_Vector3 from;
|
||||
MT_Vector3 to;
|
||||
MT_Vector3 color;
|
||||
if (!PyVecTo(ob_from, from))
|
||||
return NULL;
|
||||
if (!PyVecTo(ob_to, to))
|
||||
@ -840,9 +840,9 @@ static struct PyMethodDef rasterizer_methods[] = {
|
||||
METH_VARARGS, "showMouse(bool visible)"},
|
||||
{"setMousePosition",(PyCFunction) gPySetMousePosition,
|
||||
METH_VARARGS, "setMousePosition(int x,int y)"},
|
||||
{"setBackgroundColor",(PyCFunction)gPySetBackgroundColor,METH_VARARGS,"set Background Color (rgb)"},
|
||||
{"setAmbientColor",(PyCFunction)gPySetAmbientColor,METH_VARARGS,"set Ambient Color (rgb)"},
|
||||
{"setMistColor",(PyCFunction)gPySetMistColor,METH_VARARGS,"set Mist Color (rgb)"},
|
||||
{"setBackgroundColor",(PyCFunction)gPySetBackgroundColor,METH_O,"set Background Color (rgb)"},
|
||||
{"setAmbientColor",(PyCFunction)gPySetAmbientColor,METH_O,"set Ambient Color (rgb)"},
|
||||
{"setMistColor",(PyCFunction)gPySetMistColor,METH_O,"set Mist Color (rgb)"},
|
||||
{"setMistStart",(PyCFunction)gPySetMistStart,METH_VARARGS,"set Mist Start(rgb)"},
|
||||
{"setMistEnd",(PyCFunction)gPySetMistEnd,METH_VARARGS,"set Mist End(rgb)"},
|
||||
{"enableMotionBlur",(PyCFunction)gPyEnableMotionBlur,METH_VARARGS,"enable motion blur"},
|
||||
|
||||
@ -1512,9 +1512,9 @@ double KX_Scene::getSuspendedDelta()
|
||||
//Python
|
||||
|
||||
PyMethodDef KX_Scene::Methods[] = {
|
||||
KX_PYMETHODTABLE(KX_Scene, getLightList),
|
||||
KX_PYMETHODTABLE(KX_Scene, getObjectList),
|
||||
KX_PYMETHODTABLE(KX_Scene, getName),
|
||||
KX_PYMETHODTABLE_NOARGS(KX_Scene, getLightList),
|
||||
KX_PYMETHODTABLE_NOARGS(KX_Scene, getObjectList),
|
||||
KX_PYMETHODTABLE_NOARGS(KX_Scene, getName),
|
||||
|
||||
{NULL,NULL} //Sentinel
|
||||
};
|
||||
@ -1549,12 +1549,11 @@ PyObject* KX_Scene::_getattr(const char *attr)
|
||||
if (!strcmp(attr, "name"))
|
||||
return PyString_FromString(GetName());
|
||||
|
||||
if (!strcmp(attr, "objects"))
|
||||
return (PyObject*) m_objectlist->AddRef();
|
||||
|
||||
if (!strcmp(attr, "active_camera"))
|
||||
{
|
||||
KX_Camera *camera = GetActiveCamera();
|
||||
camera->AddRef();
|
||||
return (PyObject*) camera;
|
||||
}
|
||||
return (PyObject*) GetActiveCamera()->AddRef();
|
||||
|
||||
if (!strcmp(attr, "suspended"))
|
||||
return PyInt_FromLong(m_suspend);
|
||||
@ -1589,25 +1588,24 @@ int KX_Scene::_setattr(const char *attr, PyObject *pyvalue)
|
||||
return PyObjectPlus::_setattr(attr, pyvalue);
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Scene, getLightList,
|
||||
KX_PYMETHODDEF_DOC_NOARGS(KX_Scene, getLightList,
|
||||
"getLightList() -> list [KX_Light]\n"
|
||||
"Returns a list of all lights in the scene.\n"
|
||||
)
|
||||
{
|
||||
m_lightlist->AddRef();
|
||||
return (PyObject*) m_lightlist;
|
||||
return (PyObject*) m_lightlist->AddRef();
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Scene, getObjectList,
|
||||
KX_PYMETHODDEF_DOC_NOARGS(KX_Scene, getObjectList,
|
||||
"getObjectList() -> list [KX_GameObject]\n"
|
||||
"Returns a list of all game objects in the scene.\n"
|
||||
)
|
||||
{
|
||||
m_objectlist->AddRef();
|
||||
return (PyObject*) m_objectlist;
|
||||
// ShowDeprecationWarning("getObjectList()", "the objects property"); // XXX Grr, why doesnt this work?
|
||||
return (PyObject*) m_objectlist->AddRef();
|
||||
}
|
||||
|
||||
KX_PYMETHODDEF_DOC(KX_Scene, getName,
|
||||
KX_PYMETHODDEF_DOC_NOARGS(KX_Scene, getName,
|
||||
"getName() -> string\n"
|
||||
"Returns the name of the scene.\n"
|
||||
)
|
||||
|
||||
@ -547,9 +547,9 @@ public:
|
||||
*/
|
||||
void SetNodeTree(SG_Tree* root);
|
||||
|
||||
KX_PYMETHOD_DOC(KX_Scene, getLightList);
|
||||
KX_PYMETHOD_DOC(KX_Scene, getObjectList);
|
||||
KX_PYMETHOD_DOC(KX_Scene, getName);
|
||||
KX_PYMETHOD_DOC_NOARGS(KX_Scene, getLightList);
|
||||
KX_PYMETHOD_DOC_NOARGS(KX_Scene, getObjectList);
|
||||
KX_PYMETHOD_DOC_NOARGS(KX_Scene, getName);
|
||||
/*
|
||||
KX_PYMETHOD_DOC(KX_Scene, getActiveCamera);
|
||||
KX_PYMETHOD_DOC(KX_Scene, getActiveCamera);
|
||||
|
||||
@ -63,18 +63,18 @@ PyParentObject KX_VertexProxy::Parents[] = {
|
||||
};
|
||||
|
||||
PyMethodDef KX_VertexProxy::Methods[] = {
|
||||
{"getXYZ", (PyCFunction)KX_VertexProxy::sPyGetXYZ,METH_VARARGS},
|
||||
{"setXYZ", (PyCFunction)KX_VertexProxy::sPySetXYZ,METH_VARARGS},
|
||||
{"getUV", (PyCFunction)KX_VertexProxy::sPyGetUV,METH_VARARGS},
|
||||
{"setUV", (PyCFunction)KX_VertexProxy::sPySetUV,METH_VARARGS},
|
||||
{"getXYZ", (PyCFunction)KX_VertexProxy::sPyGetXYZ,METH_NOARGS},
|
||||
{"setXYZ", (PyCFunction)KX_VertexProxy::sPySetXYZ,METH_O},
|
||||
{"getUV", (PyCFunction)KX_VertexProxy::sPyGetUV,METH_NOARGS},
|
||||
{"setUV", (PyCFunction)KX_VertexProxy::sPySetUV,METH_O},
|
||||
|
||||
{"getUV2", (PyCFunction)KX_VertexProxy::sPyGetUV2,METH_VARARGS},
|
||||
{"getUV2", (PyCFunction)KX_VertexProxy::sPyGetUV2,METH_NOARGS},
|
||||
{"setUV2", (PyCFunction)KX_VertexProxy::sPySetUV2,METH_VARARGS},
|
||||
|
||||
{"getRGBA", (PyCFunction)KX_VertexProxy::sPyGetRGBA,METH_VARARGS},
|
||||
{"setRGBA", (PyCFunction)KX_VertexProxy::sPySetRGBA,METH_VARARGS},
|
||||
{"getNormal", (PyCFunction)KX_VertexProxy::sPyGetNormal,METH_VARARGS},
|
||||
{"setNormal", (PyCFunction)KX_VertexProxy::sPySetNormal,METH_VARARGS},
|
||||
{"getRGBA", (PyCFunction)KX_VertexProxy::sPyGetRGBA,METH_NOARGS},
|
||||
{"setRGBA", (PyCFunction)KX_VertexProxy::sPySetRGBA,METH_O},
|
||||
{"getNormal", (PyCFunction)KX_VertexProxy::sPyGetNormal,METH_NOARGS},
|
||||
{"setNormal", (PyCFunction)KX_VertexProxy::sPySetNormal,METH_O},
|
||||
{NULL,NULL} //Sentinel
|
||||
};
|
||||
|
||||
@ -312,130 +312,103 @@ void KX_VertexProxy::ReplicaSetName(STR_String) {};
|
||||
|
||||
// stuff for python integration
|
||||
|
||||
PyObject* KX_VertexProxy::PyGetXYZ(PyObject*,
|
||||
PyObject*,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PyGetXYZ(PyObject*)
|
||||
{
|
||||
return PyObjectFrom(MT_Point3(m_vertex->getXYZ()));
|
||||
}
|
||||
|
||||
PyObject* KX_VertexProxy::PySetXYZ(PyObject*,
|
||||
PyObject* args,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PySetXYZ(PyObject*, PyObject* value)
|
||||
{
|
||||
MT_Point3 vec;
|
||||
if (PyVecArgTo(args, vec))
|
||||
{
|
||||
if (!PyVecTo(value, vec))
|
||||
return NULL;
|
||||
|
||||
m_vertex->SetXYZ(vec);
|
||||
m_mesh->SetMeshModified(true);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
PyObject* KX_VertexProxy::PyGetNormal(PyObject*,
|
||||
PyObject*,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PyGetNormal(PyObject*)
|
||||
{
|
||||
return PyObjectFrom(MT_Vector3(m_vertex->getNormal()));
|
||||
}
|
||||
|
||||
PyObject* KX_VertexProxy::PySetNormal(PyObject*,
|
||||
PyObject* args,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PySetNormal(PyObject*, PyObject* value)
|
||||
{
|
||||
MT_Vector3 vec;
|
||||
if (PyVecArgTo(args, vec))
|
||||
{
|
||||
if (!PyVecTo(value, vec))
|
||||
return NULL;
|
||||
|
||||
m_vertex->SetNormal(vec);
|
||||
m_mesh->SetMeshModified(true);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
PyObject* KX_VertexProxy::PyGetRGBA(PyObject*,
|
||||
PyObject*,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PyGetRGBA(PyObject*)
|
||||
{
|
||||
int *rgba = (int *) m_vertex->getRGBA();
|
||||
return PyInt_FromLong(*rgba);
|
||||
}
|
||||
|
||||
PyObject* KX_VertexProxy::PySetRGBA(PyObject*,
|
||||
PyObject* args,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PySetRGBA(PyObject*, PyObject* value)
|
||||
{
|
||||
float r, g, b, a;
|
||||
if (PyArg_ParseTuple(args, "(ffff)", &r, &g, &b, &a))
|
||||
{
|
||||
m_vertex->SetRGBA(MT_Vector4(r, g, b, a));
|
||||
m_mesh->SetMeshModified(true);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
PyErr_Clear();
|
||||
|
||||
int rgba;
|
||||
if (PyArg_ParseTuple(args,"i",&rgba))
|
||||
{
|
||||
if PyInt_Check(value) {
|
||||
int rgba = PyInt_AsLong(value);
|
||||
m_vertex->SetRGBA(rgba);
|
||||
m_mesh->SetMeshModified(true);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
else {
|
||||
MT_Vector4 vec;
|
||||
if (PyVecTo(value, vec))
|
||||
{
|
||||
m_vertex->SetRGBA(vec);
|
||||
m_mesh->SetMeshModified(true);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
PyErr_SetString(PyExc_TypeError, "expected a 4D vector or an int");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
PyObject* KX_VertexProxy::PyGetUV(PyObject*,
|
||||
PyObject*,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PyGetUV(PyObject*)
|
||||
{
|
||||
return PyObjectFrom(MT_Vector2(m_vertex->getUV1()));
|
||||
}
|
||||
|
||||
PyObject* KX_VertexProxy::PySetUV(PyObject*,
|
||||
PyObject* args,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PySetUV(PyObject*, PyObject* value)
|
||||
{
|
||||
MT_Point2 vec;
|
||||
if (PyVecArgTo(args, vec))
|
||||
{
|
||||
if (!PyVecTo(value, vec))
|
||||
return NULL;
|
||||
|
||||
m_vertex->SetUV(vec);
|
||||
m_mesh->SetMeshModified(true);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
PyObject* KX_VertexProxy::PyGetUV2(PyObject*,
|
||||
PyObject*,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PyGetUV2(PyObject*)
|
||||
{
|
||||
return PyObjectFrom(MT_Vector2(m_vertex->getUV2()));
|
||||
}
|
||||
|
||||
PyObject* KX_VertexProxy::PySetUV2(PyObject*,
|
||||
PyObject* args,
|
||||
PyObject*)
|
||||
PyObject* KX_VertexProxy::PySetUV2(PyObject*, PyObject* args)
|
||||
{
|
||||
MT_Point2 vec;
|
||||
unsigned int unit=0;
|
||||
PyObject* list=0;
|
||||
if(PyArg_ParseTuple(args, "Oi", &list, &unit))
|
||||
{
|
||||
if (PyVecTo(list, vec))
|
||||
{
|
||||
PyObject* list= NULL;
|
||||
if(!PyArg_ParseTuple(args, "Oi:setUV2", &list, &unit))
|
||||
return NULL;
|
||||
|
||||
if (!PyVecTo(list, vec))
|
||||
return NULL;
|
||||
|
||||
m_vertex->SetFlag((m_vertex->getFlag()|RAS_TexVert::SECOND_UV));
|
||||
m_vertex->SetUnit(unit);
|
||||
m_vertex->SetUV2(vec);
|
||||
m_mesh->SetMeshModified(true);
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -57,18 +57,18 @@ public:
|
||||
virtual PyObject* _getattr(const char *attr);
|
||||
virtual int _setattr(const char *attr, PyObject *pyvalue);
|
||||
|
||||
KX_PYMETHOD(KX_VertexProxy,GetXYZ);
|
||||
KX_PYMETHOD(KX_VertexProxy,SetXYZ);
|
||||
KX_PYMETHOD(KX_VertexProxy,GetUV);
|
||||
KX_PYMETHOD(KX_VertexProxy,SetUV);
|
||||
KX_PYMETHOD_NOARGS(KX_VertexProxy,GetXYZ);
|
||||
KX_PYMETHOD_O(KX_VertexProxy,SetXYZ);
|
||||
KX_PYMETHOD_NOARGS(KX_VertexProxy,GetUV);
|
||||
KX_PYMETHOD_O(KX_VertexProxy,SetUV);
|
||||
|
||||
KX_PYMETHOD(KX_VertexProxy,GetUV2);
|
||||
KX_PYMETHOD(KX_VertexProxy,SetUV2);
|
||||
KX_PYMETHOD_NOARGS(KX_VertexProxy,GetUV2);
|
||||
KX_PYMETHOD_VARARGS(KX_VertexProxy,SetUV2);
|
||||
|
||||
KX_PYMETHOD(KX_VertexProxy,GetRGBA);
|
||||
KX_PYMETHOD(KX_VertexProxy,SetRGBA);
|
||||
KX_PYMETHOD(KX_VertexProxy,GetNormal);
|
||||
KX_PYMETHOD(KX_VertexProxy,SetNormal);
|
||||
KX_PYMETHOD_NOARGS(KX_VertexProxy,GetRGBA);
|
||||
KX_PYMETHOD_O(KX_VertexProxy,SetRGBA);
|
||||
KX_PYMETHOD_NOARGS(KX_VertexProxy,GetNormal);
|
||||
KX_PYMETHOD_O(KX_VertexProxy,SetNormal);
|
||||
|
||||
};
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user