/*

 * C++ RayTracer

 * Module for Python

 * file: raytracermodule.cc

 *

 * Radek Brich, 2006

 */

#include <Python.h>

#include <vector>

#include "scene.h"

#include "raytracer.h"

//=========================== 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_Getattr(PyObject *self, char *name);

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

static PyTypeObject LightType = {

	PyObject_HEAD_INIT(NULL)

	0,				/*ob_size*/

	"Light",			/*tp_name*/

	sizeof(LightObject),		/*tp_basicsize*/

	0,				/*tp_itemsize*/

	/* methods */

	Light_Destructor,		/*tp_dealloc*/

	0,				/*tp_print*/

	Light_Getattr,			/*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 */

};

static PyMethodDef LightMethods[] = {

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

	{NULL, NULL}

};

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;

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

	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(Vector3(px, py, pz), Colour(cr, cg, cb));

	return (PyObject*)v;

}

static void Light_Destructor(PyObject* self)

{

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

	PyObject_Del(self);

}

static PyObject *Light_Getattr(PyObject *self, char *name)

{

	return Py_FindMethod(LightMethods, self, name);

}

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;

}

//=========================== 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_Getattr(PyObject *self, char *name);

static PyTypeObject MaterialType = {

	PyObject_HEAD_INIT(NULL)

	0,				/*ob_size*/

	"Material",			/*tp_name*/

	sizeof(MaterialObject),		/*tp_basicsize*/

	0,				/*tp_itemsize*/

	/* methods */

	Material_Destructor,		/*tp_dealloc*/

	0,				/*tp_print*/

	Material_Getattr,			/*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 */

};

static PyMethodDef MaterialMethods[] = {

	{NULL, NULL}

};

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;

	PyObject_Del(self);

}

static PyObject *Material_Getattr(PyObject *self, char *name)

{

	return Py_FindMethod(MaterialMethods, self, name);

}

//=========================== 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_Getattr(PyObject *self, char *name);

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

static PyTypeObject NormalVertexType = {

	PyObject_HEAD_INIT(NULL)

	0,				/*ob_size*/

	"NormalVertex",			/*tp_name*/

	sizeof(NormalVertexObject),		/*tp_basicsize*/

	0,				/*tp_itemsize*/

	/* methods */

	NormalVertex_Destructor,		/*tp_dealloc*/

	0,				/*tp_print*/

	NormalVertex_Getattr,			/*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 */

};

static PyMethodDef NormalVertexMethods[] = {

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

	{NULL, NULL}

};

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,

		&PyTuple_Type, &TVer, &PyTuple_Type, &TNor))

		return NULL;

	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(Vector3(vx, vy, vz), Vector3(nx, ny, nz));

	return (PyObject*)v;

}

static void NormalVertex_Destructor(PyObject* self)

{

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

	PyObject_Del(self);

}

static PyObject *NormalVertex_Getattr(PyObject *self, char *name)

{

	return Py_FindMethod(NormalVertexMethods, self, name);

}

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(Vector3(nx,ny,nz).normalize());

	Py_INCREF(Py_None);

	return Py_None;

}

//=========================== Sphere Object ===========================

typedef struct {

	PyObject_HEAD

	Sphere *shape;

} SphereObject;

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

static void Sphere_Destructor(PyObject* self);

static PyObject *Sphere_Getattr(PyObject *self, char *name);

static PyTypeObject SphereType = {

	PyObject_HEAD_INIT(NULL)

	0,				/*ob_size*/

	"Sphere",			/*tp_name*/

	sizeof(SphereObject),		/*tp_basicsize*/

	0,				/*tp_itemsize*/

	/* methods */

	Sphere_Destructor,		/*tp_dealloc*/

	0,				/*tp_print*/

	Sphere_Getattr,			/*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 */

};

static PyMethodDef SphereMethods[] = {

	{NULL, NULL}

};

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

{

	SphereObject *v;

	MaterialObject *material;

	static char *kwdlist[] = {"centre", "radius", "material", NULL};

	PyObject *TCentre = NULL;

	Float cx, cy, cz, radius;

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

		&PyTuple_Type, &TCentre, &radius, &MaterialType, &material))

		return NULL;

	if (!PyArg_ParseTuple(TCentre, "fff", &cx, &cy, &cz))

		return NULL;

	v = PyObject_New(SphereObject, &SphereType);

	v->shape = new Sphere(Vector3(cx, cy, cz), radius, material->material);

	Py_INCREF(material);

	return (PyObject*)v;

}

static void Sphere_Destructor(PyObject* self)

{

	delete ((SphereObject *)self)->shape;

	PyObject_Del(self);

}

static PyObject *Sphere_Getattr(PyObject *self, char *name)

{

	return Py_FindMethod(SphereMethods, self, name);

}

//=========================== Box Object ===========================

typedef struct {

	PyObject_HEAD

	Box *shape;

} BoxObject;

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

static void Box_Destructor(PyObject* self);

static PyObject *Box_Getattr(PyObject *self, char *name);

static PyTypeObject BoxType = {

	PyObject_HEAD_INIT(NULL)

	0,				/*ob_size*/

	"Box",			/*tp_name*/

	sizeof(BoxObject),		/*tp_basicsize*/

	0,				/*tp_itemsize*/

	/* methods */

	Box_Destructor,		/*tp_dealloc*/

	0,				/*tp_print*/

	Box_Getattr,			/*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 */

};

static PyMethodDef BoxMethods[] = {

	{NULL, NULL}

};

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

{

	BoxObject *v;

	MaterialObject *material;

	static char *kwdlist[] = {"L", "H", "material", NULL};

	PyObject *TL = NULL;

	PyObject *TH = NULL;

	Float lx, ly, lz, hx, hy, hz;

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

		&PyTuple_Type, &TL, &PyTuple_Type, &TH, &MaterialType, &material))

		return NULL;

	if (!PyArg_ParseTuple(TL, "fff", &lx, &ly, &lz))

		return NULL;

	if (!PyArg_ParseTuple(TH, "fff", &hx, &hy, &hz))

		return NULL;

	v = PyObject_New(BoxObject, &BoxType);

	v->shape = new Box(Vector3(lx, ly, lz), Vector3(hx, hy, hz), material->material);

	Py_INCREF(material);

	return (PyObject*)v;

}

static void Box_Destructor(PyObject* self)

{

	delete ((BoxObject *)self)->shape;

	PyObject_Del(self);

}

static PyObject *Box_Getattr(PyObject *self, char *name)

{

	return Py_FindMethod(BoxMethods, self, name);

}

//=========================== Triangle Object ===========================

typedef struct {

	PyObject_HEAD

	Triangle *triangle;

} TriangleObject;

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

static void Triangle_Destructor(PyObject* self);

static PyObject *Triangle_Getattr(PyObject *self, char *name);

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

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

static PyTypeObject TriangleType = {

	PyObject_HEAD_INIT(NULL)

	0,				/*ob_size*/

	"Triangle",			/*tp_name*/

	sizeof(TriangleObject),		/*tp_basicsize*/

	0,				/*tp_itemsize*/

	/* methods */

	Triangle_Destructor,		/*tp_dealloc*/

	0,				/*tp_print*/

	Triangle_Getattr,			/*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 */

};

static PyMethodDef TriangleMethods[] = {

	{"getNormal", (PyCFunction)Triangle_getNormal, METH_NOARGS, "Get normal of whole triangle."},

	{"setSmooth", (PyCFunction)Triangle_setSmooth, METH_NOARGS, "Set the triangle smooth."},

	{NULL, NULL}

};

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

{

	TriangleObject *v;

	MaterialObject *material;

	static char *kwdlist[] = {"A", "B", "C", "material", NULL};

	NormalVertexObject *A, *B, *C;

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

		&NormalVertexType, &A, &NormalVertexType, &B, &NormalVertexType, &C,

		&MaterialType, &material))

		return NULL;

	v = PyObject_New(TriangleObject, &TriangleType);

	v->triangle = new Triangle(A->nvertex, B->nvertex, C->nvertex, material->material);

	Py_INCREF(material);

	Py_INCREF(A);

	Py_INCREF(B);

	Py_INCREF(C);

	return (PyObject*)v;

}

static void Triangle_Destructor(PyObject* self)

{

	delete ((TriangleObject *)self)->triangle;

	PyObject_Del(self);

}

static PyObject *Triangle_Getattr(PyObject *self, char *name)

{

	return Py_FindMethod(TriangleMethods, self, name);

}

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

{

	PyObject *obj;

	Vector3 N = ((TriangleObject *)self)->triangle->getNormal();

	obj = Py_BuildValue("(fff)", N.x, N.y, N.z);

	return obj;

}

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

{

	((TriangleObject *)self)->triangle->setSmooth();

	Py_INCREF(Py_None);

	return Py_None;

}

//=========================== Raytracer Object ===========================

typedef struct {

	PyObject_HEAD

	Raytracer *raytracer;

	vector<PyObject*> *children;

} RaytracerObject;

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

static void Raytracer_Destructor(PyObject* self);

static PyObject *Raytracer_Getattr(PyObject *self, char *name);

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

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

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

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

static PyTypeObject RaytracerType = {

	PyObject_HEAD_INIT(NULL)

	0,				/*ob_size*/

	"Raytracer",			/*tp_name*/

	sizeof(RaytracerObject),	/*tp_basicsize*/

	0,				/*tp_itemsize*/

	/* methods */

	Raytracer_Destructor,		/*tp_dealloc*/

	0,				/*tp_print*/

	Raytracer_Getattr,		/*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 */

};

static PyMethodDef RaytracerMethods[] = {

	{"render", (PyCFunction)Raytracer_render, METH_VARARGS, "Render scene and return image data."},

	{"addshape", (PyCFunction)Raytracer_addshape, METH_VARARGS, "Add new shape to scene."},

	{"addlight", (PyCFunction)Raytracer_addlight, METH_VARARGS, "Add new light source to scene."},

	{"ambientocclusion", (PyCFunction)Raytracer_ambientocclusion, METH_VARARGS | METH_KEYWORDS,

		"Set ambient occlusion parametrs - samples: int (0 = disable), distance: float, angle: float."},