You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

407 lines
14 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "cyPhysics.h"
#include "pyKey.h"
#include "pyGeometry3.h"
#include "pyMatrix44.h"
#include <python.h>
// glue functions
PYTHON_CLASS_DEFINITION(ptPhysics, cyPhysics);
PYTHON_DEFAULT_NEW_DEFINITION(ptPhysics, cyPhysics)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptPhysics)
PYTHON_INIT_DEFINITION(ptPhysics, args, keywords)
{
PYTHON_RETURN_INIT_OK;
}
PYTHON_METHOD_DEFINITION(ptPhysics, netForce, args)
{
char forceFlag;
if (!PyArg_ParseTuple(args, "b", &forceFlag))
{
PyErr_SetString(PyExc_TypeError, "netForce requires a boolean argument");
PYTHON_RETURN_ERROR;
}
self->fThis->SetNetForce(forceFlag != 0);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, enable, args)
{
char stateFlag = 1;
if (!PyArg_ParseTuple(args, "|b", &stateFlag))
{
PyErr_SetString(PyExc_TypeError, "enable expects an optional boolean argument");
PYTHON_RETURN_ERROR;
}
self->fThis->EnableT(stateFlag != 0);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_METHOD_DEFINITION(ptPhysics, disable, Disable)
PYTHON_BASIC_METHOD_DEFINITION(ptPhysics, disableCollision, DisableCollision)
PYTHON_BASIC_METHOD_DEFINITION(ptPhysics, enableCollision, EnableCollision)
PYTHON_METHOD_DEFINITION(ptPhysics, warp, args)
{
PyObject *positionObject = NULL;
if (!PyArg_ParseTuple(args, "O", &positionObject))
{
PyErr_SetString(PyExc_TypeError, "warp expects a ptPoint3 or ptMatrix44 object");
PYTHON_RETURN_ERROR;
}
if (pyPoint3::Check(positionObject))
{
pyPoint3 *pos = pyPoint3::ConvertFrom(positionObject);
self->fThis->Warp(*pos);
PYTHON_RETURN_NONE;
}
else if (pyMatrix44::Check(positionObject))
{
pyMatrix44 *mat = pyMatrix44::ConvertFrom(positionObject);
self->fThis->WarpMat(*mat);
PYTHON_RETURN_NONE;
}
PyErr_SetString(PyExc_TypeError, "warp expects a ptPoint3 or ptMatrix44 object");
PYTHON_RETURN_ERROR;
}
PYTHON_METHOD_DEFINITION(ptPhysics, warpObj, args)
{
PyObject *keyObject = NULL;
if (!PyArg_ParseTuple(args, "O", &keyObject))
{
PyErr_SetString(PyExc_TypeError, "warpObj expects a ptKey");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObject))
{
PyErr_SetString(PyExc_TypeError, "warpObj expects a ptKey");
PYTHON_RETURN_ERROR;
}
pyKey *key = pyKey::ConvertFrom(keyObject);
self->fThis->WarpObj(*key);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, move, args)
{
PyObject *directionObject = NULL;
float distance;
if (!PyArg_ParseTuple(args, "Of", &directionObject, &distance))
{
PyErr_SetString(PyExc_TypeError, "move expects a ptVector3 and float");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(directionObject))
{
PyErr_SetString(PyExc_TypeError, "move expects a ptVector3 and float");
PYTHON_RETURN_ERROR;
}
pyVector3 *direction = pyVector3::ConvertFrom(directionObject);
self->fThis->Move(*direction, distance);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, rotate, args)
{
float radians;
PyObject *axisObject = NULL;
if (!PyArg_ParseTuple(args, "fO", &radians, &axisObject))
{
PyErr_SetString(PyExc_TypeError, "rotate expects a float and ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(axisObject))
{
PyErr_SetString(PyExc_TypeError, "rotate expects a float and ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *axis = pyVector3::ConvertFrom(axisObject);
self->fThis->Rotate(radians, *axis);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, force, args)
{
PyObject *forceObject = NULL;
if (!PyArg_ParseTuple(args, "O", &forceObject))
{
PyErr_SetString(PyExc_TypeError, "force expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(forceObject))
{
PyErr_SetString(PyExc_TypeError, "force expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *force = pyVector3::ConvertFrom(forceObject);
self->fThis->Force(*force);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, forceWithOffset, args)
{
PyObject *forceObject = NULL;
PyObject *offsetObject = NULL;
if (!PyArg_ParseTuple(args, "OO", &forceObject, &offsetObject))
{
PyErr_SetString(PyExc_TypeError, "forceWithOffset expects a ptVector3 and a ptPoint3");
PYTHON_RETURN_ERROR;
}
if ((!pyVector3::Check(forceObject)) || (!pyPoint3::Check(offsetObject)))
{
PyErr_SetString(PyExc_TypeError, "forceWithOffset expects a ptVector3 and a ptPoint3");
PYTHON_RETURN_ERROR;
}
pyVector3 *force = pyVector3::ConvertFrom(forceObject);
pyPoint3 *offset = pyPoint3::ConvertFrom(offsetObject);
self->fThis->ForceWithOffset(*force, *offset);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, torque, args)
{
PyObject *torqueObject = NULL;
if (!PyArg_ParseTuple(args, "O", &torqueObject))
{
PyErr_SetString(PyExc_TypeError, "torque expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(torqueObject))
{
PyErr_SetString(PyExc_TypeError, "torque expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *torque = pyVector3::ConvertFrom(torqueObject);
self->fThis->Torque(*torque);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, impulse, args)
{
PyObject *forceObject = NULL;
if (!PyArg_ParseTuple(args, "O", &forceObject))
{
PyErr_SetString(PyExc_TypeError, "impulse expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(forceObject))
{
PyErr_SetString(PyExc_TypeError, "impulse expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *force = pyVector3::ConvertFrom(forceObject);
self->fThis->Impulse(*force);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, impulseWithOffset, args)
{
PyObject *forceObject = NULL;
PyObject *offsetObject = NULL;
if (!PyArg_ParseTuple(args, "OO", &forceObject, &offsetObject))
{
PyErr_SetString(PyExc_TypeError, "impulseWithOffset expects a ptVector3 and a ptPoint3");
PYTHON_RETURN_ERROR;
}
if ((!pyVector3::Check(forceObject)) || (!pyPoint3::Check(offsetObject)))
{
PyErr_SetString(PyExc_TypeError, "impulseWithOffset expects a ptVector3 and a ptPoint3");
PYTHON_RETURN_ERROR;
}
pyVector3 *force = pyVector3::ConvertFrom(forceObject);
pyPoint3 *offset = pyPoint3::ConvertFrom(offsetObject);
self->fThis->ImpulseWithOffset(*force, *offset);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, angularImpulse, args)
{
PyObject *forceObject = NULL;
if (!PyArg_ParseTuple(args, "O", &forceObject))
{
PyErr_SetString(PyExc_TypeError, "angularImpulse expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(forceObject))
{
PyErr_SetString(PyExc_TypeError, "angularImpulse expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *force = pyVector3::ConvertFrom(forceObject);
self->fThis->AngularImpulse(*force);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, damp, args)
{
float damp;
if (!PyArg_ParseTuple(args, "f", &damp))
{
PyErr_SetString(PyExc_TypeError, "damp expects a float");
PYTHON_RETURN_ERROR;
}
self->fThis->Damp(damp);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, shiftMass, args)
{
PyObject *offestObject = NULL;
if (!PyArg_ParseTuple(args, "O", &offestObject))
{
PyErr_SetString(PyExc_TypeError, "shiftMass expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(offestObject))
{
PyErr_SetString(PyExc_TypeError, "shiftMass expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *offset = pyVector3::ConvertFrom(offestObject);
self->fThis->ShiftMass(*offset);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, suppress, args)
{
char doSuppress;
if (!PyArg_ParseTuple(args, "b", &doSuppress))
{
PyErr_SetString(PyExc_TypeError, "suppress expects a boolean");
PYTHON_RETURN_NONE;
}
self->fThis->Suppress(doSuppress != 0);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, setLinearVelocity, args)
{
PyObject *velocity = NULL;
if (!PyArg_ParseTuple(args, "O", &velocity))
{
PyErr_SetString(PyExc_TypeError, "setVelocity expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(velocity))
{
PyErr_SetString(PyExc_TypeError, "setVelocity expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *velocityVec = pyVector3::ConvertFrom(velocity);
self->fThis->SetLinearVelocity(*velocityVec);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPhysics, setAngularVelocity, args)
{
PyObject *velocity = NULL;
if (!PyArg_ParseTuple(args, "O", &velocity))
{
PyErr_SetString(PyExc_TypeError, "setAngularVelocity expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(velocity))
{
PyErr_SetString(PyExc_TypeError, "setAngularVelocity expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *velocityVec = pyVector3::ConvertFrom(velocity);
self->fThis->SetAngularVelocity(*velocityVec);
PYTHON_RETURN_NONE;
}
PYTHON_START_METHODS_TABLE(ptPhysics)
PYTHON_METHOD(ptPhysics, netForce, "Params: forceFlag\nSpecify whether this object needs to use messages that are forced to the network\n"
"- This is to be used if your Python program is running on only one client\n"
"Such as a game master, only running on the client that owns a particular object"),
PYTHON_METHOD(ptPhysics, enable, "Params: state=1\nSets the physics enable state for the sceneobject attached"),
PYTHON_BASIC_METHOD(ptPhysics, disable, "Disables physics on the sceneobject attached"),
PYTHON_BASIC_METHOD(ptPhysics, disableCollision, "Disables collision detection on the attached sceneobject"),
PYTHON_BASIC_METHOD(ptPhysics, enableCollision, "Enables collision detection on the attached sceneobject"),
PYTHON_METHOD(ptPhysics, warp, "Params: position\nWarps the sceneobject to a specified location.\n"
"'position' can be a ptPoint3 or a ptMatrix44"),
PYTHON_METHOD(ptPhysics, warpObj, "Params: objkey\nWarps the sceneobject to match the location and orientation of the specified object"),
PYTHON_METHOD(ptPhysics, move, "Params: direction,distance\nMoves the attached sceneobject the specified distance in the specified direction"),
PYTHON_METHOD(ptPhysics, rotate, "Params: radians,axis\nRotates the attached sceneobject the specified radians around the specified axis"),
PYTHON_METHOD(ptPhysics, force, "Params: forceVector\nApplies the specified force to the attached sceneobject"),
PYTHON_METHOD(ptPhysics, forceWithOffset, "Params: forceVector,offsetPt\nApplies the specified offsetted force to the attached sceneobject"),
PYTHON_METHOD(ptPhysics, torque, "Params: torqueVector\nApplies the specified torque to the attached sceneobject"),
PYTHON_METHOD(ptPhysics, impulse, "Params: impulseVector\nAdds the given vector to the attached sceneobject's velocity"),
PYTHON_METHOD(ptPhysics, impulseWithOffset, "Params: impulseVector,offsetPt\nAdds the given vector to the attached sceneobject's velocity\n"
"with the specified offset"),
PYTHON_METHOD(ptPhysics, angularImpulse, "Params: impulseVector\nAdd the given vector (representing a rotation axis and magnitude) to\n"
"the attached sceneobject's velocity"),
PYTHON_METHOD(ptPhysics, damp, "Params: damp\nReduce all velocities on the object (0 = all stop, 1 = no effect)"),
PYTHON_METHOD(ptPhysics, shiftMass, "Params: offsetVector\nShifts the attached sceneobject's center to mass in the specified direction and distance"),
PYTHON_METHOD(ptPhysics, suppress, "Params: doSuppress\nCompletely remove the physical, but keep it around so it\n"
"can be added back later."),
PYTHON_METHOD(ptPhysics, setLinearVelocity, "Params: velocityVector\nSets the objects LinearVelocity to the specified vector"),
PYTHON_METHOD(ptPhysics, setAngularVelocity, "Params: velocityVector\nSets the objects AngularVelocity to the specified vector"),
PYTHON_END_METHODS_TABLE;
// Type structure definition
PLASMA_DEFAULT_TYPE(ptPhysics, "Plasma physics class");
// required functions for PyObject interoperability
PyObject *cyPhysics::New(PyObject *sender, PyObject *recvr)
{
ptPhysics *newObj = (ptPhysics*)ptPhysics_type.tp_new(&ptPhysics_type, NULL, NULL);
if (sender != NULL)
{
pyKey *senderKey = pyKey::ConvertFrom(sender);
newObj->fThis->SetSender(senderKey->getKey());
}
if (recvr != NULL)
{
pyKey *recvrKey = pyKey::ConvertFrom(recvr);
newObj->fThis->AddRecvr(recvrKey->getKey());
}
newObj->fThis->SetNetForce(false);
return (PyObject*)newObj;
}
PYTHON_CLASS_CHECK_IMPL(ptPhysics, cyPhysics)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptPhysics, cyPhysics)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void cyPhysics::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptPhysics);
PYTHON_CLASS_IMPORT_END(m);
}