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.
 
 
 
 
 

449 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 "pyGeometry3.h"
#include <python.h>
// glue functions
PYTHON_CLASS_DEFINITION(ptPoint3, pyPoint3);
PYTHON_DEFAULT_NEW_DEFINITION(ptPoint3, pyPoint3)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptPoint3)
PYTHON_INIT_DEFINITION(ptPoint3, args, keywords)
{
float x = 0.0f, y = 0.0f, z = 0.0f;
if (!PyArg_ParseTuple(args, "|fff", &x, &y, &z))
{
PyErr_SetString(PyExc_TypeError, "init optionally expects three floats");
PYTHON_RETURN_INIT_ERROR;
}
self->fThis->fPoint.fX = x;
self->fThis->fPoint.fY = y;
self->fThis->fPoint.fZ = z;
PYTHON_RETURN_INIT_OK;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptPoint3, getX)
{
return PyFloat_FromDouble((double)self->fThis->getX());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptPoint3, getY)
{
return PyFloat_FromDouble((double)self->fThis->getY());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptPoint3, getZ)
{
return PyFloat_FromDouble((double)self->fThis->getZ());
}
PYTHON_METHOD_DEFINITION(ptPoint3, setX, args)
{
float x;
if (!PyArg_ParseTuple(args, "f", &x))
{
PyErr_SetString(PyExc_TypeError, "setX expects a float");
PYTHON_RETURN_ERROR;
}
self->fThis->setX(x);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPoint3, setY, args)
{
float y;
if (!PyArg_ParseTuple(args, "f", &y))
{
PyErr_SetString(PyExc_TypeError, "setY expects a float");
PYTHON_RETURN_ERROR;
}
self->fThis->setY(y);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptPoint3, setZ, args)
{
float z;
if (!PyArg_ParseTuple(args, "f", &z))
{
PyErr_SetString(PyExc_TypeError, "setZ expects a float");
PYTHON_RETURN_ERROR;
}
self->fThis->setZ(z);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_METHOD_DEFINITION(ptPoint3, zero, Zero)
PYTHON_METHOD_DEFINITION_NOARGS(ptPoint3, copy)
{
return self->fThis->Copy();
}
PYTHON_METHOD_DEFINITION(ptPoint3, distance, args)
{
PyObject *otherObject = NULL;
if (!PyArg_ParseTuple(args, "O", &otherObject))
{
PyErr_SetString(PyExc_TypeError, "distance expects a ptPoint3");
PYTHON_RETURN_ERROR;
}
if (!pyPoint3::Check(otherObject))
{
PyErr_SetString(PyExc_TypeError, "distance expects a ptPoint3");
PYTHON_RETURN_ERROR;
}
pyPoint3 *other = pyPoint3::ConvertFrom(otherObject);
return PyFloat_FromDouble((double)self->fThis->Distance(*other));
}
PYTHON_METHOD_DEFINITION(ptPoint3, distanceSq, args)
{
PyObject *otherObject = NULL;
if (!PyArg_ParseTuple(args, "O", &otherObject))
{
PyErr_SetString(PyExc_TypeError, "distanceSq expects a ptPoint3");
PYTHON_RETURN_ERROR;
}
if (!pyPoint3::Check(otherObject))
{
PyErr_SetString(PyExc_TypeError, "distanceSq expects a ptPoint3");
PYTHON_RETURN_ERROR;
}
pyPoint3 *other = pyPoint3::ConvertFrom(otherObject);
return PyFloat_FromDouble((double)self->fThis->DistanceSquared(*other));
}
PYTHON_START_METHODS_TABLE(ptPoint3)
PYTHON_METHOD_NOARGS(ptPoint3, getX, "Returns the 'x' component of the point"),
PYTHON_METHOD_NOARGS(ptPoint3, getY, "Returns the 'y' component of the point"),
PYTHON_METHOD_NOARGS(ptPoint3, getZ, "Returns the 'z' component of the point"),
PYTHON_METHOD(ptPoint3, setX, "Params: x\nSets the 'x' component of the point"),
PYTHON_METHOD(ptPoint3, setY, "Params: y\nSets the 'y' component of the point"),
PYTHON_METHOD(ptPoint3, setZ, "Params: z\nSets the 'z' component of the point"),
PYTHON_BASIC_METHOD(ptPoint3, zero, "Sets the 'x','y' and the 'z' component to zero"),
PYTHON_METHOD_NOARGS(ptPoint3, copy, "Returns a copy of the point in another ptPoint3 object"),
PYTHON_METHOD(ptPoint3, distance, "Params: other\nComputes the distance from this point to 'other' point"),
PYTHON_METHOD(ptPoint3, distanceSq, "Params: other\nComputes the distance squared from this point to 'other' point\n"
"- this function is faster than distance(other)"),
PYTHON_END_METHODS_TABLE;
// Type structure definition
PLASMA_DEFAULT_TYPE(ptPoint3, "Params: x=0, y=0, z=0\nPlasma Point class");
// required functions for PyObject interoperability
PYTHON_CLASS_NEW_IMPL(ptPoint3, pyPoint3)
PyObject *pyPoint3::New(const hsPoint3 &obj)
{
ptPoint3 *newObj = (ptPoint3*)ptPoint3_type.tp_new(&ptPoint3_type, NULL, NULL);
newObj->fThis->fPoint.Set(&obj);
return (PyObject*)newObj;
}
PYTHON_CLASS_CHECK_IMPL(ptPoint3, pyPoint3)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptPoint3, pyPoint3)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyPoint3::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptPoint3);
PYTHON_CLASS_IMPORT_END(m);
}
// glue functions
PYTHON_CLASS_DEFINITION(ptVector3, pyVector3);
PYTHON_DEFAULT_NEW_DEFINITION(ptVector3, pyVector3)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptVector3)
PYTHON_INIT_DEFINITION(ptVector3, args, keywords)
{
float x = 0.0f, y = 0.0f, z = 0.0f;
if (!PyArg_ParseTuple(args, "|fff", &x, &y, &z))
{
PyErr_SetString(PyExc_TypeError, "init optionally expects three floats");
PYTHON_RETURN_INIT_ERROR;
}
self->fThis->fVector.fX = x;
self->fThis->fVector.fY = y;
self->fThis->fVector.fZ = z;
PYTHON_RETURN_INIT_OK;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVector3, getX)
{
return PyFloat_FromDouble((double)self->fThis->getX());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVector3, getY)
{
return PyFloat_FromDouble((double)self->fThis->getY());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVector3, getZ)
{
return PyFloat_FromDouble((double)self->fThis->getZ());
}
PYTHON_METHOD_DEFINITION(ptVector3, setX, args)
{
float x;
if (!PyArg_ParseTuple(args, "f", &x))
{
PyErr_SetString(PyExc_TypeError, "setX expects a float");
PYTHON_RETURN_ERROR;
}
self->fThis->setX(x);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVector3, setY, args)
{
float y;
if (!PyArg_ParseTuple(args, "f", &y))
{
PyErr_SetString(PyExc_TypeError, "setY expects a float");
PYTHON_RETURN_ERROR;
}
self->fThis->setY(y);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVector3, setZ, args)
{
float z;
if (!PyArg_ParseTuple(args, "f", &z))
{
PyErr_SetString(PyExc_TypeError, "setZ expects a float");
PYTHON_RETURN_ERROR;
}
self->fThis->setZ(z);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_METHOD_DEFINITION(ptVector3, zero, Zero)
PYTHON_METHOD_DEFINITION_NOARGS(ptVector3, copy)
{
return self->fThis->Copy();
}
PYTHON_METHOD_DEFINITION(ptVector3, scale, args)
{
float scale;
if (!PyArg_ParseTuple(args, "f", &scale))
{
PyErr_SetString(PyExc_TypeError, "scale expects a float");
PYTHON_RETURN_ERROR;
}
return self->fThis->Scale(scale);
}
PYTHON_METHOD_DEFINITION(ptVector3, add, args)
{
PyObject *otherObject;
if (!PyArg_ParseTuple(args, "O", &otherObject))
{
PyErr_SetString(PyExc_TypeError, "add expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(otherObject))
{
PyErr_SetString(PyExc_TypeError, "add expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *other = pyVector3::ConvertFrom(otherObject);
return self->fThis->Add(*other);
}
PYTHON_METHOD_DEFINITION(ptVector3, subtract, args)
{
PyObject *otherObject;
if (!PyArg_ParseTuple(args, "O", &otherObject))
{
PyErr_SetString(PyExc_TypeError, "subtract expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(otherObject))
{
PyErr_SetString(PyExc_TypeError, "subtract expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *other = pyVector3::ConvertFrom(otherObject);
return self->fThis->Subtract(*other);
}
PYTHON_BASIC_METHOD_DEFINITION(ptVector3, normalize, Normalize)
PYTHON_METHOD_DEFINITION(ptVector3, dotProduct, args)
{
PyObject *otherObject;
if (!PyArg_ParseTuple(args, "O", &otherObject))
{
PyErr_SetString(PyExc_TypeError, "dotProduct expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(otherObject))
{
PyErr_SetString(PyExc_TypeError, "dotProduct expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *other = pyVector3::ConvertFrom(otherObject);
return PyFloat_FromDouble((double)self->fThis->Dot(*other));
}
PYTHON_METHOD_DEFINITION(ptVector3, crossProduct, args)
{
PyObject *otherObject;
if (!PyArg_ParseTuple(args, "O", &otherObject))
{
PyErr_SetString(PyExc_TypeError, "crossProduct expects a ptVector3");
PYTHON_RETURN_ERROR;
}
if (!pyVector3::Check(otherObject))
{
PyErr_SetString(PyExc_TypeError, "crossProduct expects a ptVector3");
PYTHON_RETURN_ERROR;
}
pyVector3 *other = pyVector3::ConvertFrom(otherObject);
return self->fThis->Cross(*other);
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVector3, length)
{
return PyFloat_FromDouble((double)self->fThis->Magnitude());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVector3, lengthSq)
{
return PyFloat_FromDouble((double)self->fThis->MagnitudeSquared());
}
PYTHON_START_METHODS_TABLE(ptVector3)
PYTHON_METHOD_NOARGS(ptVector3, getX, "Returns the 'x' component of the vector"),
PYTHON_METHOD_NOARGS(ptVector3, getY, "Returns the 'y' component of the vector"),
PYTHON_METHOD_NOARGS(ptVector3, getZ, "Returns the 'z' component of the vector"),
PYTHON_METHOD(ptVector3, setX, "Params: x\nSets the 'x' component of the vector"),
PYTHON_METHOD(ptVector3, setY, "Params: y\nSets the 'y' component of the vector"),
PYTHON_METHOD(ptVector3, setZ, "Params: z\nSets the 'z' component of the vector"),
PYTHON_BASIC_METHOD(ptVector3, zero, "Zeros the vector's components"),
PYTHON_METHOD_NOARGS(ptVector3, copy, "Copies the vector into another one (which it returns)"),
PYTHON_METHOD(ptVector3, scale, "Params: scale\nScale the vector by scale"),
PYTHON_METHOD(ptVector3, add, "Params: other\nAdds other to the current vector"),
PYTHON_METHOD(ptVector3, subtract, "Params: other\nSubtracts other from the current vector"),
PYTHON_BASIC_METHOD(ptVector3, normalize, "Normalizes the vector to length 1"),
PYTHON_METHOD(ptVector3, dotProduct, "Params: other\nFinds the dot product between other and this vector"),
PYTHON_METHOD(ptVector3, crossProduct, "Params: other\nFinds the cross product between other and this vector"),
PYTHON_METHOD_NOARGS(ptVector3, length, "Returns the length of the vector"),
PYTHON_METHOD_NOARGS(ptVector3, lengthSq, "Returns the length of the vector, squared\n"
"- this function is faster then length(other)"),
PYTHON_END_METHODS_TABLE;
PyObject *ptVector3_sub(PyObject *v, PyObject *w)
{
if (pyVector3::Check(v))
{
pyVector3 *me = pyVector3::ConvertFrom(v);
if (pyVector3::Check(w))
{
pyVector3 *other = pyVector3::ConvertFrom(w);
return (*me) - (*other);
}
}
PyErr_SetString(PyExc_NotImplementedError, "can only subtract a ptVector3 from a ptVector3");
PYTHON_RETURN_NOT_IMPLEMENTED;
}
PyObject *ptVector3_add(PyObject *v, PyObject *w)
{
if (pyVector3::Check(v))
{
pyVector3 *me = pyVector3::ConvertFrom(v);
if (pyVector3::Check(w))
{
pyVector3 *other = pyVector3::ConvertFrom(w);
return (*me) + (*other);
}
}
PyErr_SetString(PyExc_NotImplementedError, "can only subtract a ptVector3 from a ptVector3");
PYTHON_RETURN_NOT_IMPLEMENTED;
}
PYTHON_START_AS_NUMBER_TABLE(ptVector3)
(binaryfunc)ptVector3_add, /*nb_add*/
(binaryfunc)ptVector3_sub, /*nb_subtract*/
0, /*nb_multiply*/
0 /*nb_divide*/
/* the rest can be null */
PYTHON_END_AS_NUMBER_TABLE;
// Type structure definition
#define ptVector3_COMPARE PYTHON_NO_COMPARE
#define ptVector3_AS_NUMBER PYTHON_DEFAULT_AS_NUMBER(ptVector3)
#define ptVector3_AS_SEQUENCE PYTHON_NO_AS_SEQUENCE
#define ptVector3_AS_MAPPING PYTHON_NO_AS_MAPPING
#define ptVector3_STR PYTHON_NO_STR
#define ptVector3_RICH_COMPARE PYTHON_NO_RICH_COMPARE
#define ptVector3_GETSET PYTHON_NO_GETSET
#define ptVector3_BASE PYTHON_NO_BASE
PLASMA_CUSTOM_TYPE(ptVector3, "Params: x=0, y=0, z=0\nPlasma Point class");
// required functions for PyObject interoperability
PYTHON_CLASS_NEW_IMPL(ptVector3, pyVector3)
PyObject *pyVector3::New(const hsVector3 &obj)
{
ptVector3 *newObj = (ptVector3*)ptVector3_type.tp_new(&ptVector3_type, NULL, NULL);
newObj->fThis->fVector.Set(&obj);
return (PyObject*)newObj;
}
PYTHON_CLASS_CHECK_IMPL(ptVector3, pyVector3)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptVector3, pyVector3)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyVector3::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptVector3);
PYTHON_CLASS_IMPORT_END(m);
}