/*

 * raytracermodule.cc: Python module

 *

 * This file is part of Pyrit Ray Tracer.

 *

 * Copyright 2006, 2007, 2008  Radek Brich

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include <Python.h>

#include <vector>

#include "raytracer.h"

#include "octree.h"

#include "kdtree.h"

#define TYPE_OBJECT(name, basicsize, dealloc, flags, doc, methods, members, base, init) \

{ \

	PyObject_HEAD_INIT(NULL) \

	0,                          /* ob_size */ \

	(name),                     /* tp_name */ \

	(basicsize),                /* tp_basicsize*/ \

	0,                          /* tp_itemsize*/ \

	(dealloc),                  /* 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*/\

	PyObject_GenericGetAttr,    /* tp_getattro*/\

	0,                          /* tp_setattro*/\

	0,                          /* tp_as_buffer*/\

	(flags),                    /* tp_flags*/\

	(doc),                      /* tp_doc */\

	0,                          /* tp_traverse */\

	0,                          /* tp_clear */\

	0,                          /* tp_richcompare */\

	0,                          /* tp_weaklistoffset */\

	0,                          /* tp_iter */\

	0,                          /* tp_iternext */\

	(methods),                  /* tp_methods */\

	(members),                  /* tp_members */\

	0,                          /* tp_getset */\

	(base),                     /* tp_base */\

	0,                          /* tp_dict */ \

	0,                          /* tp_descr_get */ \

	0,                          /* tp_descr_set */ \

	0,                          /* tp_dictoffset */ \

	(init),                     /* tp_init */ \

	0,                          /* tp_alloc */ \

	0,                          /* tp_new */ \

	0,                          /* tp_free */ \

}

//=========================== Light Source Object ===========================

typedef struct {

	PyObject_HEAD

	Light *light;

} LightObject;

static PyObject *Light_Constructor(PyObject* self, PyObject* args, PyObject *kwd);

static void Light_Destructor(PyObject* self);

static PyObject *Light_castShadows(PyObject* self, PyObject* args);

static PyMethodDef LightMethods[] = {

	{"castShadows", (PyCFunction)Light_castShadows, METH_VARARGS, "Enable or disable shadows from this light."},

	{NULL, NULL}

};

static PyTypeObject LightType =

TYPE_OBJECT(

	"Light",                    /* tp_name */

	sizeof(LightObject),        /* tp_basicsize */

	Light_Destructor,           /* tp_dealloc */

	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /* tp_flags */

	"Light type",               /* tp_doc */

	LightMethods,               /* tp_methods */

	0,                          /* tp_members */

	0,                          /* tp_base */

	0                           /* tp_init */

);

static PyObject* Light_Constructor(PyObject* self, PyObject* args, PyObject *kwd)

{

	LightObject *v;

	static char *kwdlist[] = {"position", "colour", NULL};

	PyObject *TPos, *TCol = NULL;

	Float px, py, pz;

	if (!PyArg_ParseTupleAndKeywords(args, kwd, "O!|O!", kwdlist,

		&PyTuple_Type, &TPos, &PyTuple_Type, &TCol))

		return NULL;

	if (!PyArg_ParseTuple(TPos, "fff", &px, &py, &pz))

		return NULL;

	if (TCol && !PyArg_ParseTuple(TCol, "fff", &cr, &cg, &cb))

		return NULL;

	v = PyObject_New(LightObject, &LightType);

	v->light = new Light(Vector(px, py, pz), Colour(cr, cg, cb));

	return (PyObject*)v;

}

static void Light_Destructor(PyObject* self)

{

	delete ((LightObject *)self)->light;

	self->ob_type->tp_free(self);

}

static PyObject *Light_castShadows(PyObject* self, PyObject* args)

{

	int shadows = 1;

	if (!PyArg_ParseTuple(args, "i", &shadows))

		return NULL;

	((LightObject *)self)->light->castShadows(shadows);

	Py_INCREF(Py_None);

	return Py_None;

}

//=========================== Camera Object ===========================

typedef struct {

	PyObject_HEAD

	Camera *camera;

} CameraObject;

static PyObject *Camera_Constructor(PyObject* self, PyObject* args, PyObject *kwd);

static void Camera_Destructor(PyObject* self);

static PyObject *Camera_setEye(PyObject* self, PyObject* args);

static PyObject *Camera_setAngle(PyObject* self, PyObject* args);

static PyObject *Camera_rotate(PyObject* self, PyObject* args);

static PyMethodDef CameraMethods[] = {

	{"setEye", (PyCFunction)Camera_setEye, METH_VARARGS, "Set eye of the camera."},

	{"setAngle", (PyCFunction)Camera_setAngle, METH_VARARGS, "Set vertical angle of view."},

	{"rotate", (PyCFunction)Camera_rotate, METH_VARARGS, "Rotate camera with a quaternion."},

	{NULL, NULL}

};

static PyTypeObject CameraType =

TYPE_OBJECT(

	"Camera",                    /* tp_name */

	sizeof(CameraObject),        /* tp_basicsize */

	Camera_Destructor,           /* tp_dealloc */

	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /* tp_flags */

	"Camera type",               /* tp_doc */

	CameraMethods,               /* tp_methods */

	0,                           /* tp_members */

	0,                           /* tp_base */

	0                            /* tp_init */

);

static PyObject* Camera_Constructor(PyObject* self, PyObject* args, PyObject *kwd)

{

	CameraObject *v;

	static char *kwdlist[] = {"eye", "lookat", "up", "p", "u", "v", NULL};

	PyObject *TEye = NULL, *TLookAt = NULL, *TUp = NULL,

		*Tp = NULL, *Tu = NULL, *Tv = NULL;

	Float ex=0.0,  ey=0.0, ez=10.0;

	Float lax=0.0, lay=0.0, laz=0.0;

	Float upx=0.0, upy=1.0, upz=0.0;

	Float px=0.0,  py=0.0, pz=-1.0;

	Float ux=-1.0, uy=0.0, uz=0.0;

	Float vx=0.0,  vy=1.0, vz=0.0;

	if (!PyArg_ParseTupleAndKeywords(args, kwd, "|O!O!O!O!O!O!", kwdlist,

		&PyTuple_Type, &TEye, &PyTuple_Type, &TLookAt, &PyTuple_Type, &TUp,

		&PyTuple_Type, &Tp, &PyTuple_Type, &Tu, &PyTuple_Type, &Tv))

		return NULL;

	if (TEye)

		if (!PyArg_ParseTuple(TEye, "fff", &ex, &ey, &ez))

			return NULL;

	if (TLookAt)

		if (!PyArg_ParseTuple(TLookAt, "fff", &lax, &lay, &laz))

			return NULL;

	if (TUp)

		if (!PyArg_ParseTuple(TUp, "fff", &upx, &upy, &upz))

			return NULL;

	if (Tp)

		if (!PyArg_ParseTuple(Tp, "fff", &px, &py, &pz))

			return NULL;

	if (Tu)

		if (!PyArg_ParseTuple(Tu, "fff", &ux, &uy, &uz))

			return NULL;

	if (Tv)

		if (!PyArg_ParseTuple(Tv, "fff", &vx, &vy, &vz))

			return NULL;

	v = PyObject_New(CameraObject, &CameraType);

	if (TLookAt)

		v->camera = new Camera(Vector(ex, ey, ez),

			Vector(lax, lay, laz), Vector(upx, upy, upz));

	else

		v->camera = new Camera(Vector(ex, ey, ez),

			Vector(px, py, pz), Vector(ux, uy, uz), Vector(vx, vy, vz));

	return (PyObject*)v;

}

static void Camera_Destructor(PyObject* self)

{

	delete ((CameraObject *)self)->camera;

	self->ob_type->tp_free(self);

}

static PyObject *Camera_setEye(PyObject* self, PyObject* args)

{

	PyObject *TEye = NULL;

	Float ex=0.0,  ey=0.0, ez=10.0;

	if (!PyArg_ParseTuple(args, "O!", &PyTuple_Type, &TEye))

		return NULL;

	if (TEye)

		if (!PyArg_ParseTuple(TEye, "fff", &ex, &ey, &ez))

			return NULL;

	((CameraObject *)self)->camera->setEye(Vector(ex, ey, ez));

	Py_INCREF(Py_None);

	return Py_None;

}

static PyObject *Camera_setAngle(PyObject* self, PyObject* args)

{

	Float angle;

	if (!PyArg_ParseTuple(args, "f", &angle))

		return NULL;

	((CameraObject *)self)->camera->setAngle(angle);

	Py_INCREF(Py_None);

	return Py_None;

}

static PyObject *Camera_rotate(PyObject* self, PyObject* args)

{

	PyObject *Tq = NULL;

	Float qa, qb, qc, qd;

	if (!PyArg_ParseTuple(args, "O!", &PyTuple_Type, &Tq))

		return NULL;

	if (!PyArg_ParseTuple(Tq, "ffff", &qa, &qb, &qc, &qd))

		return NULL;

	((CameraObject *)self)->camera->rotate(Quaternion(qa, qb, qc, qd).normalize());

	Py_INCREF(Py_None);

	return Py_None;

}

//=========================== Material Object ===========================

typedef struct {

	PyObject_HEAD

	Material *material;

} MaterialObject;

static PyObject *Material_Constructor(PyObject* self, PyObject* args, PyObject *kwd);

static void Material_Destructor(PyObject* self);

static PyObject *Material_setPhong(PyObject* self, PyObject* args);

static PyObject *Material_setReflectivity(PyObject* self, PyObject* args);

static PyObject *Material_setTransmissivity(PyObject* self, PyObject* args);

static PyObject *Material_setSmooth(PyObject* self, PyObject* args);

static PyMethodDef MaterialMethods[] = {

	{"setPhong", (PyCFunction)Material_setPhong, METH_VARARGS, "Set ambient, diffuse, specular and shininess Phong model constants."},

	{"setReflectivity", (PyCFunction)Material_setReflectivity, METH_VARARGS, "Set reflectivity."},

	{"setTransmissivity", (PyCFunction)Material_setTransmissivity, METH_VARARGS, "Set transmissivity and refraction index."},

	{"setSmooth", (PyCFunction)Material_setSmooth, METH_VARARGS, "Set triangle smoothing."},

	{NULL, NULL}

};

static PyTypeObject MaterialType =

TYPE_OBJECT(

	"Material",                    /* tp_name */

	sizeof(MaterialObject),        /* tp_basicsize */

	Material_Destructor,           /* tp_dealloc */

	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /* tp_flags */

	"Material type",               /* tp_doc */

	MaterialMethods,               /* tp_methods */

	0,                             /* tp_members */

	0,                             /* tp_base */

	0                              /* tp_init */

);

static PyObject* Material_Constructor(PyObject* self, PyObject* args, PyObject *kwd)

{

	MaterialObject *v;

	static char *kwdlist[] = {"colour", NULL};

	PyObject *TCol = NULL;

	Float cr=1.0, cg=1.0, cb=1.0;

	if (!PyArg_ParseTupleAndKeywords(args, kwd, "|O!", kwdlist,

		&PyTuple_Type, &TCol))

		return NULL;

	if (TCol)

		if (!PyArg_ParseTuple(TCol, "fff", &cr, &cg, &cb))

			return NULL;

	v = PyObject_New(MaterialObject, &MaterialType);

	v->material = new Material(Colour(cr, cg, cb));

	return (PyObject*)v;

}

static void Material_Destructor(PyObject* self)

{

	delete ((MaterialObject *)self)->material;

	self->ob_type->tp_free(self);

}

static PyObject *Material_setPhong(PyObject* self, PyObject* args)

{

	Float amb, dif, spec, shin = 0.5;

	if (!PyArg_ParseTuple(args, "fff|f", &amb, &dif, &spec, &shin))

		return NULL;

	((MaterialObject *)self)->material->setPhong(amb, dif, spec, shin);

	Py_INCREF(Py_None);

	return Py_None;

}

static PyObject *Material_setReflectivity(PyObject* self, PyObject* args)

{

	Float refl;

	if (!PyArg_ParseTuple(args, "f", &refl))

		return NULL;

	((MaterialObject *)self)->material->setReflectivity(refl);

	Py_INCREF(Py_None);

	return Py_None;

}

static PyObject *Material_setTransmissivity(PyObject* self, PyObject* args)

{

	if (!PyArg_ParseTuple(args, "f|f", &trans, &rindex))

		return NULL;

	((MaterialObject *)self)->material->setTransmissivity(trans, rindex);

	Py_INCREF(Py_None);

	return Py_None;

}

static PyObject* Material_setSmooth(PyObject* self, PyObject* args)

{

	int smooth;

	if (!PyArg_ParseTuple(args, "i", &smooth))

		return NULL;

	((MaterialObject *)self)->material->setSmooth(smooth);

	Py_INCREF(Py_None);

	return Py_None;

}

//=========================== NormalVertex Object ===========================

typedef struct {

	PyObject_HEAD

	NormalVertex *nvertex;

} NormalVertexObject;

static PyObject *NormalVertex_Constructor(PyObject* self, PyObject* args, PyObject *kwd);

static void NormalVertex_Destructor(PyObject* self);

static PyObject *NormalVertex_setNormal(PyObject* self, PyObject* args);

static PyMethodDef NormalVertexMethods[] = {

	{"setNormal", (PyCFunction)NormalVertex_setNormal, METH_VARARGS, "Set normal of this vertex."},

	{NULL, NULL}

};

static PyTypeObject NormalVertexType =

TYPE_OBJECT(

	"NormalVertex",                    /* tp_name */

	sizeof(NormalVertexObject),        /* tp_basicsize */

	NormalVertex_Destructor,           /* tp_dealloc */

	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /* tp_flags */

	"NormalVertex type",               /* tp_doc */

	NormalVertexMethods,               /* tp_methods */

	0,                                 /* tp_members */

	0,                                 /* tp_base */

	0                                  /* tp_init */

);

static PyObject* NormalVertex_Constructor(PyObject* self, PyObject* args, PyObject *kwd)

{

	NormalVertexObject *v;

	static char *kwdlist[] = {"vector", "normal", NULL};

	PyObject *TVer = NULL;

	PyObject *TNor = NULL;

	Float vx, vy, vz, nx=0, ny=0, nz=0;

	if (!PyArg_ParseTupleAndKeywords(args, kwd, "O|O!", kwdlist,

		&TVer, &PyTuple_Type, &TNor))

		return NULL;

	if (!TNor && TVer->ob_type == &NormalVertexType)

	{

		v = PyObject_New(NormalVertexObject, &NormalVertexType);

		v->nvertex = new NormalVertex(((NormalVertexObject*)TVer)->nvertex);

	}

	else

	{

		if (!PyArg_ParseTuple(TVer, "fff", &vx, &vy, &vz))

			return NULL;

		if (TNor)

			if (!PyArg_ParseTuple(TNor, "fff", &nx, &ny, &nz))

				return NULL;

		v = PyObject_New(NormalVertexObject, &NormalVertexType);

		v->nvertex = new NormalVertex(Vector(vx, vy, vz), Vector(nx, ny, nz));

	}

	return (PyObject*)v;

}

static void NormalVertex_Destructor(PyObject* self)

{

	delete ((NormalVertexObject *)self)->nvertex;

	self->ob_type->tp_free(self);

}

static PyObject *NormalVertex_setNormal(PyObject* self, PyObject* args)

{

	PyObject *TNor = NULL;

	Float nx, ny, nz;

	if (!PyArg_ParseTuple(args, "O!", &PyTuple_Type, &TNor))

		return NULL;

	if (!PyArg_ParseTuple(TNor, "fff", &nx, &ny, &nz))

		return NULL;

	((NormalVertexObject *)self)->nvertex->setNormal(Vector(nx,ny,nz).normalize());

	Py_INCREF(Py_None);

	return Py_None;

}

//=========================== Shape Object (abstract) ===========================

typedef struct {

	PyObject_HEAD

	Shape *shape;

} ShapeObject;

static void Shape_Destructor(PyObject* self);

static PyMethodDef ShapeMethods[] = {