mirror of
https://github.com/worldforge/cyphesis
synced 2026-08-13 12:26:04 -04:00
921 lines
33 KiB
C++
921 lines
33 KiB
C++
// Cyphesis Online RPG Server and AI Engine
|
|
// Copyright (C) 2011 Alistair Riddoch
|
|
//
|
|
// 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 2 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, write to the Free Software Foundation,
|
|
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
|
|
#include "Py_Shape.h"
|
|
|
|
#include "Py_BBox.h"
|
|
#include "Py_Message.h"
|
|
#include "Py_Point3D.h"
|
|
|
|
#include "common/log.h"
|
|
|
|
#include "physics/Shape.h"
|
|
|
|
#include "physics/Course.h"
|
|
|
|
#include <Atlas/Message/Element.h>
|
|
|
|
#include <wfmath/axisbox.h>
|
|
#include <wfmath/line.h>
|
|
#include <wfmath/point.h>
|
|
#include <wfmath/polygon.h>
|
|
|
|
#include <sstream>
|
|
#include <iostream>
|
|
|
|
template<int dim> class LinearCourse : public Course<dim, WFMath::Line>
|
|
{
|
|
};
|
|
|
|
using Atlas::Message::Element;
|
|
using Atlas::Message::ListType;
|
|
using Atlas::Message::MapType;
|
|
|
|
static PyObject * Shape_area(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.area");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
return PyFloat_FromDouble(self->shape.s->area());
|
|
}
|
|
|
|
static PyObject * Shape_footprint(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.footprint");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
PyShape * res = newPyBox();
|
|
if (res != 0) {
|
|
res->shape.p = new MathShape<WFMath::AxisBox, 2>(self->shape.s->footprint());
|
|
}
|
|
return (PyObject*)res;
|
|
}
|
|
|
|
static PyObject * Shape_as_data(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.as_data");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
MapType atlas_data;
|
|
self->shape.s->toAtlas(atlas_data);
|
|
return MessageElement_asPyObject(atlas_data);
|
|
}
|
|
|
|
static PyMethodDef Shape_methods[] = {
|
|
{"area", (PyCFunction)Shape_area, METH_NOARGS},
|
|
{"footprint", (PyCFunction)Shape_footprint, METH_NOARGS},
|
|
{"as_data", (PyCFunction)Shape_as_data, METH_NOARGS},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
static PyObject * Area_centre(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.centre");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
PyPoint3D * res = newPyPoint3D();
|
|
if (res != 0) {
|
|
res->coords = self->shape.b->centre();
|
|
}
|
|
return (PyObject*)res;
|
|
}
|
|
|
|
static PyObject * Area_low_corner(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.low_corner");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
PyPoint3D * res = newPyPoint3D();
|
|
if (res != 0) {
|
|
res->coords = self->shape.b->lowCorner();
|
|
}
|
|
return (PyObject*)res;
|
|
}
|
|
|
|
static PyObject * Area_high_corner(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.high_corner");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
PyPoint3D * res = newPyPoint3D();
|
|
if (res != 0) {
|
|
res->coords = self->shape.b->highCorner();
|
|
}
|
|
return (PyObject*)res;
|
|
}
|
|
|
|
static PyMethodDef Area_methods[] = {
|
|
{"centre", (PyCFunction)Area_centre, METH_NOARGS},
|
|
{"low_corner", (PyCFunction)Area_low_corner, METH_NOARGS},
|
|
{"high_corner", (PyCFunction)Area_high_corner, METH_NOARGS},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
static PyObject * Body_centre(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.centre");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
PyPoint3D * res = newPyPoint3D();
|
|
if (res != 0) {
|
|
res->coords = self->shape.b->centre();
|
|
}
|
|
return (PyObject*)res;
|
|
}
|
|
|
|
static PyObject * Body_low_corner(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.low_corner");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
PyPoint3D * res = newPyPoint3D();
|
|
if (res != 0) {
|
|
res->coords = self->shape.b->lowCorner();
|
|
}
|
|
return (PyObject*)res;
|
|
}
|
|
|
|
static PyObject * Body_high_corner(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.high_corner");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
PyPoint3D * res = newPyPoint3D();
|
|
if (res != 0) {
|
|
res->coords = self->shape.b->highCorner();
|
|
}
|
|
return (PyObject*)res;
|
|
}
|
|
|
|
static PyMethodDef Body_methods[] = {
|
|
{"centre", (PyCFunction)Body_centre, METH_NOARGS},
|
|
{"low_corner", (PyCFunction)Body_low_corner, METH_NOARGS},
|
|
{"high_corner", (PyCFunction)Body_high_corner, METH_NOARGS},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
static PyBBox * Box_extrude(PyShape * self, PyObject * args)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.as_data");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
MathShape<WFMath::AxisBox, 2> * shape =
|
|
dynamic_cast<MathShape<WFMath::AxisBox, 2> *>(self->shape.p);
|
|
if (shape == 0) {
|
|
PyErr_SetString(PyExc_RuntimeError, "Shape is not a 2D axisbox");
|
|
return NULL;
|
|
}
|
|
float low, high;
|
|
if (!PyArg_ParseTuple(args, "ff", &low, &high)) {
|
|
return NULL;
|
|
}
|
|
PyBBox * ret = newPyBBox();
|
|
if (ret != 0) {
|
|
ret->box = BBox(Point3D(shape->shape().lowCorner().x(),
|
|
shape->shape().lowCorner().y(),
|
|
low),
|
|
Point3D(shape->shape().highCorner().x(),
|
|
shape->shape().highCorner().y(),
|
|
high), true);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static PyMethodDef Box_methods[] = {
|
|
{"extrude", (PyCFunction)Box_extrude, METH_VARARGS},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
static PyMethodDef Course_methods[] = {
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
static void Shape_dealloc(PyShape *self)
|
|
{
|
|
if (self->shape.s != NULL) {
|
|
delete self->shape.s;
|
|
}
|
|
self->ob_type->tp_free((PyObject*)self);
|
|
}
|
|
|
|
static PyObject * Shape_getattro(PyShape *self, PyObject * oname)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.getattro");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
// char * name = PyString_AsString(oname);
|
|
return PyObject_GenericGetAttr((PyObject *)self, oname);
|
|
}
|
|
|
|
static int Shape_setattro(PyShape *self, PyObject *oname, PyObject *v)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.setattr");
|
|
return -1;
|
|
}
|
|
#endif // NDEBUG
|
|
// char * name = PyString_AsString(oname);
|
|
PyErr_SetString(PyExc_AttributeError, "unknown attribute");
|
|
return -1;
|
|
}
|
|
|
|
static PyObject * Polygon_getattro(PyShape *self, PyObject * oname)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Polygon.getattro");
|
|
return NULL;
|
|
}
|
|
#endif // NDEBUG
|
|
// char * name = PyString_AsString(oname);
|
|
return PyObject_GenericGetAttr((PyObject *)self, oname);
|
|
}
|
|
|
|
static int Polygon_setattro(PyShape *self, PyObject *oname, PyObject *v)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Polygon.setattr");
|
|
return -1;
|
|
}
|
|
#endif // NDEBUG
|
|
// char * name = PyString_AsString(oname);
|
|
PyErr_SetString(PyExc_AttributeError, "unknown attribute");
|
|
return -1;
|
|
}
|
|
|
|
static PyObject * Shape_repr(PyShape *self)
|
|
{
|
|
std::stringstream r;
|
|
r << *self->shape.s;
|
|
return PyString_FromString(r.str().c_str());
|
|
}
|
|
|
|
static int Shape_init(PyShape * self, PyObject * args, PyObject * kwds)
|
|
{
|
|
PyObject * arg = 0;
|
|
if (!PyArg_ParseTuple(args, "|O", &arg)) {
|
|
return -1;
|
|
}
|
|
if (arg == 0) {
|
|
return 0;
|
|
}
|
|
if (PyDict_Check(arg)) {
|
|
MapType data;
|
|
if (PyDictObject_asElement(arg, data) != 0) {
|
|
PyErr_SetString(PyExc_TypeError, "Error converting dict to atlas");
|
|
return -1;
|
|
}
|
|
self->shape.s = Shape::newFromAtlas(data);
|
|
if (self->shape.s == 0) {
|
|
PyErr_SetString(PyExc_TypeError, "Error converting atlas to shape");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
if (PyMessage_Check(arg)) {
|
|
Element * data = ((PyMessage*)arg)->m_obj;
|
|
if (!data->isMap()) {
|
|
PyErr_SetString(PyExc_TypeError, "Error converting dict to atlas");
|
|
return -1;
|
|
}
|
|
self->shape.s = Shape::newFromAtlas(data->Map());
|
|
if (self->shape.s == 0) {
|
|
PyErr_SetString(PyExc_TypeError, "Error converting atlas to shape");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
PyErr_SetString(PyExc_TypeError, "Error converting unknown to shape");
|
|
return -1;
|
|
}
|
|
|
|
template<template <int> class ShapeT, int dim>
|
|
static int MathShape_fromListType(PyShape * self, const ListType & data)
|
|
{
|
|
self->shape.p = new MathShape<ShapeT, dim>;
|
|
if (self->shape.p == 0) {
|
|
PyErr_SetString(PyExc_MemoryError, "Error allocating shape object");
|
|
return -1;
|
|
}
|
|
int ret = self->shape.p->fromAtlas(data);
|
|
if (ret != 0) {
|
|
PyErr_SetString(PyExc_TypeError, "Error converting list to polygon");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
template<template <int> class ShapeT, int dim>
|
|
static int MathShape_init(PyShape * self, PyObject * arg)
|
|
{
|
|
if (PyList_Check(arg)) {
|
|
ListType data;
|
|
if (PyListObject_asElement(arg, data) != 0) {
|
|
PyErr_SetString(PyExc_TypeError, "Error converting list to atlas");
|
|
return -1;
|
|
}
|
|
return MathShape_fromListType<ShapeT, dim>(self, data);
|
|
}
|
|
if (PyMessage_Check(arg)) {
|
|
Element * data = ((PyMessage*)arg)->m_obj;
|
|
if (!data->isList()) {
|
|
PyErr_SetString(PyExc_TypeError, "Atlas message is not a list");
|
|
return -1;
|
|
}
|
|
return MathShape_fromListType<ShapeT, dim>(self, data->List());
|
|
}
|
|
PyErr_SetString(PyExc_TypeError, "Error converting unknown to polygon");
|
|
return -1;
|
|
}
|
|
|
|
static int Box_init(PyShape * self, PyObject * args, PyObject * kwds)
|
|
{
|
|
if (PyTuple_Size(args) != 0) {
|
|
PyErr_SetString(PyExc_TypeError, "Box shape takes no args");
|
|
return -1;
|
|
}
|
|
self->shape.p = new MathShape<WFMath::AxisBox, 2>;
|
|
return 0;
|
|
}
|
|
|
|
static int Course_init(PyShape * self, PyObject * args, PyObject * kwds)
|
|
{
|
|
PyObject * arg = 0;
|
|
if (!PyArg_ParseTuple(args, "|O", &arg)) {
|
|
return -1;
|
|
}
|
|
if (arg != 0) {
|
|
if (PyLine_Check(arg)) {
|
|
}
|
|
}
|
|
self->shape.p = new MathShape<LinearCourse, 2>;
|
|
return 0;
|
|
}
|
|
|
|
static int Line_init(PyShape * self, PyObject * args, PyObject * kwds)
|
|
{
|
|
PyObject * arg = 0;
|
|
if (!PyArg_ParseTuple(args, "O", &arg)) {
|
|
return -1;
|
|
}
|
|
return MathShape_init<WFMath::Line, 2>(self, arg);
|
|
}
|
|
|
|
static int Polygon_init(PyShape * self, PyObject * args, PyObject * kwds)
|
|
{
|
|
PyObject * arg = 0;
|
|
if (!PyArg_ParseTuple(args, "O", &arg)) {
|
|
return -1;
|
|
}
|
|
return MathShape_init<WFMath::Polygon, 2>(self, arg);
|
|
}
|
|
|
|
static PyObject * Shape_new(PyTypeObject * type, PyObject *, PyObject *)
|
|
{
|
|
// This looks allot like the default implementation
|
|
PyShape * self = (PyShape *)type->tp_alloc(type, 0);
|
|
if (self != NULL) {
|
|
self->shape.s = NULL;
|
|
}
|
|
return (PyObject *)self;
|
|
}
|
|
|
|
Py_ssize_t Shape_sq_length(PyShape * self)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.copy");
|
|
return 0;
|
|
}
|
|
#endif // NDEBUG
|
|
return self->shape.s->size();
|
|
}
|
|
|
|
PyShape * Area_sq_item(PyShape * self, Py_ssize_t index)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.copy");
|
|
return 0;
|
|
}
|
|
#endif // NDEBUG
|
|
if (static_cast<size_t>(index) >= self->shape.s->size()) {
|
|
PyErr_SetString(PyExc_IndexError, "Number of corners exceded");
|
|
return 0;
|
|
}
|
|
PyShape * a = newPyArea();
|
|
if (a != 0) {
|
|
a->shape.p =
|
|
new MathShape<WFMath::Point, 2>(self->shape.p->getCorner(index));
|
|
if (a->shape.p == 0) {
|
|
Py_DECREF(a);
|
|
a = NULL;
|
|
}
|
|
}
|
|
return a;
|
|
}
|
|
|
|
PyPoint3D * Body_sq_item(PyShape * self, Py_ssize_t index)
|
|
{
|
|
#ifndef NDEBUG
|
|
if (self->shape.s == NULL) {
|
|
PyErr_SetString(PyExc_AssertionError, "NULL Shape in Shape.copy");
|
|
return 0;
|
|
}
|
|
#endif // NDEBUG
|
|
if (static_cast<size_t>(index) >= self->shape.s->size()) {
|
|
PyErr_SetString(PyExc_IndexError, "Number of corners exceded");
|
|
return 0;
|
|
}
|
|
PyPoint3D * v = newPyPoint3D();
|
|
if (v != NULL) {
|
|
v->coords = self->shape.b->getCorner(index);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
static PyObject * Shape_inplace_multiply(PyShape * self, PyObject * other)
|
|
{
|
|
if (!PyFloat_CheckExact(other)) {
|
|
PyErr_SetString(PyExc_TypeError, "Can only scale with a float");
|
|
return NULL;
|
|
}
|
|
double val = PyFloat_AsDouble(other);
|
|
self->shape.s->scale(val);
|
|
Py_INCREF(self);
|
|
return (PyObject*)self;
|
|
}
|
|
|
|
static PyNumberMethods Shape_number = {
|
|
0, // nb_add;
|
|
0, // nb_subtract;
|
|
0, // nb_multiply;
|
|
0, // nb_divide;
|
|
0, // nb_remainder;
|
|
0, // nb_divmod;
|
|
0, // nb_power;
|
|
0, // nb_negative;
|
|
0, // nb_positive;
|
|
0, // nb_absolute;
|
|
0, // nb_nonzero;
|
|
0, // nb_invert;
|
|
0, // nb_lshift;
|
|
0, // nb_rshift;
|
|
0, // nb_and;
|
|
0, // nb_xor;
|
|
0, // nb_or;
|
|
0, // nb_coerce;
|
|
0, // nb_int;
|
|
0, // nb_long;
|
|
0, // nb_float;
|
|
0, // nb_oct;
|
|
0, // nb_hex;
|
|
/* Added in release 2.0 */
|
|
0, // nb_inplace_add;
|
|
0, // nb_inplace_subtract;
|
|
(binaryfunc)Shape_inplace_multiply, // nb_inplace_multiply;
|
|
0, // nb_inplace_divide;
|
|
0, // nb_inplace_remainder;
|
|
0, // nb_inplace_power;
|
|
0, // nb_inplace_lshift;
|
|
0, // nb_inplace_rshift;
|
|
0, // nb_inplace_and;
|
|
0, // nb_inplace_xor;
|
|
0, // nb_inplace_or;
|
|
|
|
};
|
|
|
|
static PySequenceMethods Shape_sequence = {
|
|
(lenfunc)Shape_sq_length, // sq_length;
|
|
0, // sq_concat;
|
|
0, // sq_repeat;
|
|
0, // sq_item;
|
|
0, // sq_slice;
|
|
0, // sq_ass_item;
|
|
0, // sq_ass_slice;
|
|
0, // sq_contains;
|
|
/* Added in release 2.0 */
|
|
0, // sq_inplace_concat;
|
|
0, // sq_inplace_repeat;
|
|
};
|
|
|
|
// FIXME Check if inheritance will pick up sq_length from above
|
|
static PySequenceMethods Area_sequence = {
|
|
(lenfunc)Shape_sq_length, // sq_length;
|
|
0, // sq_concat;
|
|
0, // sq_repeat;
|
|
(ssizeargfunc)Area_sq_item, // sq_item;
|
|
0, // sq_slice;
|
|
0, // sq_ass_item;
|
|
0, // sq_ass_slice;
|
|
0, // sq_contains;
|
|
/* Added in release 2.0 */
|
|
0, // sq_inplace_concat;
|
|
0, // sq_inplace_repeat;
|
|
};
|
|
|
|
static PySequenceMethods Body_sequence = {
|
|
(lenfunc)Shape_sq_length, // sq_length;
|
|
0, // sq_concat;
|
|
0, // sq_repeat;
|
|
(ssizeargfunc)Body_sq_item, // sq_item;
|
|
0, // sq_slice;
|
|
0, // sq_ass_item;
|
|
0, // sq_ass_slice;
|
|
0, // sq_contains;
|
|
/* Added in release 2.0 */
|
|
0, // sq_inplace_concat;
|
|
0, // sq_inplace_repeat;
|
|
};
|
|
|
|
PyTypeObject PyShape_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"physics.Shape", /*tp_name*/
|
|
sizeof(PyShape), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor)Shape_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
(reprfunc)Shape_repr, /*tp_repr*/
|
|
&Shape_number, /*tp_as_number*/
|
|
&Shape_sequence, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0, // tp_call
|
|
0, // tp_str
|
|
(getattrofunc)Shape_getattro, // tp_getattro
|
|
(setattrofunc)Shape_setattro, // tp_setattro
|
|
0, // tp_as_buffer
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags
|
|
"Shape objects", // tp_doc
|
|
0, // tp_travers
|
|
0, // tp_clear
|
|
0, // tp_richcompare
|
|
0, // tp_weaklistoffset
|
|
0, // tp_iter
|
|
0, // tp_iternext
|
|
Shape_methods, // tp_methods
|
|
0, // tp_members
|
|
0, // tp_getset
|
|
0, // tp_base
|
|
0, // tp_dict
|
|
0, // tp_descr_get
|
|
0, // tp_descr_set
|
|
0, // tp_dictoffset
|
|
(initproc)Shape_init, // tp_init
|
|
0, // tp_alloc
|
|
Shape_new, // tp_new
|
|
};
|
|
|
|
PyTypeObject PyArea_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"physics.Area", /*tp_name*/
|
|
sizeof(PyShape), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
0, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
&Area_sequence, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0, // tp_call
|
|
0, // tp_str
|
|
0, // tp_getattro
|
|
0, // tp_setattro
|
|
0, // tp_as_buffer
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags
|
|
"Area objects", // tp_doc
|
|
0, // tp_travers
|
|
0, // tp_clear
|
|
0, // tp_richcompare
|
|
0, // tp_weaklistoffset
|
|
0, // tp_iter
|
|
0, // tp_iternext
|
|
Area_methods, // tp_methods
|
|
0, // tp_members
|
|
0, // tp_getset
|
|
&PyShape_Type, // tp_base
|
|
0, // tp_dict
|
|
0, // tp_descr_get
|
|
0, // tp_descr_set
|
|
0, // tp_dictoffset
|
|
(initproc)Box_init, // tp_init
|
|
0, // tp_alloc
|
|
Shape_new, // tp_new
|
|
};
|
|
|
|
PyTypeObject PyBody_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"physics.Body", /*tp_name*/
|
|
sizeof(PyShape), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
0, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
&Body_sequence, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0, // tp_call
|
|
0, // tp_str
|
|
0, // tp_getattro
|
|
0, // tp_setattro
|
|
0, // tp_as_buffer
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags
|
|
"Body objects", // tp_doc
|
|
0, // tp_travers
|
|
0, // tp_clear
|
|
0, // tp_richcompare
|
|
0, // tp_weaklistoffset
|
|
0, // tp_iter
|
|
0, // tp_iternext
|
|
Body_methods, // tp_methods
|
|
0, // tp_members
|
|
0, // tp_getset
|
|
&PyShape_Type, // tp_base
|
|
0, // tp_dict
|
|
0, // tp_descr_get
|
|
0, // tp_descr_set
|
|
0, // tp_dictoffset
|
|
(initproc)Box_init, // tp_init
|
|
0, // tp_alloc
|
|
Shape_new, // tp_new
|
|
};
|
|
|
|
PyTypeObject PyBox_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"physics.Box", /*tp_name*/
|
|
sizeof(PyShape), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
0, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0, // tp_call
|
|
0, // tp_str
|
|
0, // tp_getattro
|
|
0, // tp_setattro
|
|
0, // tp_as_buffer
|
|
Py_TPFLAGS_DEFAULT, // tp_flags
|
|
"Box objects", // tp_doc
|
|
0, // tp_travers
|
|
0, // tp_clear
|
|
0, // tp_richcompare
|
|
0, // tp_weaklistoffset
|
|
0, // tp_iter
|
|
0, // tp_iternext
|
|
Box_methods, // tp_methods
|
|
0, // tp_members
|
|
0, // tp_getset
|
|
&PyArea_Type, // tp_base
|
|
0, // tp_dict
|
|
0, // tp_descr_get
|
|
0, // tp_descr_set
|
|
0, // tp_dictoffset
|
|
(initproc)Box_init, // tp_init
|
|
0, // tp_alloc
|
|
Shape_new, // tp_new
|
|
};
|
|
|
|
PyTypeObject PyCourse_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"physics.Course", /*tp_name*/
|
|
sizeof(PyShape), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
0, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0, // tp_call
|
|
0, // tp_str
|
|
0, // tp_getattro
|
|
0, // tp_setattro
|
|
0, // tp_as_buffer
|
|
Py_TPFLAGS_DEFAULT, // tp_flags
|
|
"Course objects", // tp_doc
|
|
0, // tp_travers
|
|
0, // tp_clear
|
|
0, // tp_richcompare
|
|
0, // tp_weaklistoffset
|
|
0, // tp_iter
|
|
0, // tp_iternext
|
|
Course_methods, // tp_methods
|
|
0, // tp_members
|
|
0, // tp_getset
|
|
&PyArea_Type, // tp_base
|
|
0, // tp_dict
|
|
0, // tp_descr_get
|
|
0, // tp_descr_set
|
|
0, // tp_dictoffset
|
|
(initproc)Course_init, // tp_init
|
|
0, // tp_alloc
|
|
Shape_new, // tp_new
|
|
};
|
|
|
|
PyTypeObject PyLine_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"physics.Line", /*tp_name*/
|
|
sizeof(PyShape), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
0, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0, // tp_call
|
|
0, // tp_str
|
|
0, // tp_getattro
|
|
0, // tp_setattro
|
|
0, // tp_as_buffer
|
|
Py_TPFLAGS_DEFAULT, // tp_flags
|
|
"Line objects", // tp_doc
|
|
0, // tp_travers
|
|
0, // tp_clear
|
|
0, // tp_richcompare
|
|
0, // tp_weaklistoffset
|
|
0, // tp_iter
|
|
0, // tp_iternext
|
|
0, // tp_methods
|
|
0, // tp_members
|
|
0, // tp_getset
|
|
&PyArea_Type, // tp_base
|
|
0, // tp_dict
|
|
0, // tp_descr_get
|
|
0, // tp_descr_set
|
|
0, // tp_dictoffset
|
|
(initproc)Line_init, // tp_init
|
|
0, // tp_alloc
|
|
Shape_new, // tp_new
|
|
};
|
|
|
|
PyTypeObject PyPolygon_Type = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"physics.Polygon", /*tp_name*/
|
|
sizeof(PyShape), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
0, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
0, // tp_call
|
|
0, // tp_str
|
|
(getattrofunc)Polygon_getattro, // tp_getattro
|
|
(setattrofunc)Polygon_setattro, // tp_setattro
|
|
0, // tp_as_buffer
|
|
Py_TPFLAGS_DEFAULT, // tp_flags
|
|
"Polygon objects", // tp_doc
|
|
0, // tp_travers
|
|
0, // tp_clear
|
|
0, // tp_richcompare
|
|
0, // tp_weaklistoffset
|
|
0, // tp_iter
|
|
0, // tp_iternext
|
|
0, // tp_methods
|
|
0, // tp_members
|
|
0, // tp_getset
|
|
&PyArea_Type, // tp_base
|
|
0, // tp_dict
|
|
0, // tp_descr_get
|
|
0, // tp_descr_set
|
|
0, // tp_dictoffset
|
|
(initproc)Polygon_init, // tp_init
|
|
0, // tp_alloc
|
|
Shape_new, // tp_new
|
|
};
|
|
|
|
PyShape * wrapShape(Shape * shape)
|
|
{
|
|
PyShape * wrapper = NULL;
|
|
Form<2> * plan = dynamic_cast<Form<2> *>(shape);
|
|
if (plan != 0) {
|
|
wrapper = newPyArea();
|
|
if (wrapper != 0) {
|
|
wrapper->shape.p = plan;
|
|
}
|
|
} else {
|
|
Form<3> * body = dynamic_cast<Form<3> *>(shape);
|
|
if (body != 0) {
|
|
wrapper = newPyBody();
|
|
if (wrapper != 0) {
|
|
wrapper->shape.b = body;
|
|
}
|
|
}
|
|
}
|
|
return wrapper;
|
|
}
|
|
|
|
PyShape * newPyShape()
|
|
{
|
|
return (PyShape *)PyShape_Type.tp_new(&PyShape_Type, 0, 0);
|
|
}
|
|
|
|
PyShape * newPyArea()
|
|
{
|
|
return (PyShape *)PyArea_Type.tp_new(&PyArea_Type, 0, 0);
|
|
}
|
|
|
|
PyShape * newPyBody()
|
|
{
|
|
return (PyShape *)PyBody_Type.tp_new(&PyBody_Type, 0, 0);
|
|
}
|
|
|
|
PyShape * newPyBox()
|
|
{
|
|
return (PyShape *)PyBox_Type.tp_new(&PyBox_Type, 0, 0);
|
|
}
|