/* 
 *
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
 *
 * 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. The Blender
 * Foundation also sells licenses for use in proprietary software under
 * the Blender License.  See http://www.blender.org/BL/ for information
 * about this.
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA	02111-1307, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * This is a new part of Blender.
 *
 * Contributor(s): Jacques Guignot
 *
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
*/

/**
 * \file World.c
 * \ingroup scripts
 * \brief Blender.World Module and World Data PyObject implementation.
 *
 * Note: Parameters between "<" and ">" are optional.  But if one of them is
 * given, all preceding ones must be given, too.	Of course, this only relates
 * to the Python functions and methods described here and only inside Python
 * code. [ This will go to another file later, probably the main exppython
 * doc file].  XXX Better: put optional args with their default value:
 * (self, name = "MyName")
 */

#include <BKE_main.h>
#include <BKE_global.h>
#include <BKE_object.h>
#include <BKE_library.h>
#include <BLI_blenlib.h>

#include "World.h"


/*****************************************************************************/
/* Python World_Type callback function prototypes:													*/
/*****************************************************************************/
static void World_DeAlloc (BPy_World *self);
//static int World_Print (BPy_World *self, FILE *fp, int flags);
static int World_SetAttr (BPy_World *self, char *name, PyObject *v);
static int World_Compare (BPy_World *a, BPy_World *b);
static PyObject *World_GetAttr (BPy_World *self, char *name);
static PyObject *World_Repr (BPy_World *self);

/*****************************************************************************/
/* Python World_Type structure definition:																	*/
/*****************************************************************************/
PyTypeObject World_Type =
{
	PyObject_HEAD_INIT(NULL)
	0,																			/* ob_size */
	"World",															 /* tp_name */
	sizeof (BPy_World),										 /* tp_basicsize */
	0,																			/* tp_itemsize */
	/* methods */
	(destructor)World_DeAlloc,						 /* tp_dealloc */
	0,								/* tp_print */
	(getattrfunc)World_GetAttr,						 /* tp_getattr */
	(setattrfunc)World_SetAttr,						 /* tp_setattr */
	(cmpfunc)World_Compare,								 /* tp_compare */
	(reprfunc)World_Repr,									 /* tp_repr */
	0,																			/* tp_as_number */
	0,																			/* tp_as_sequence */
	0,																			/* tp_as_mapping */
	0,																			/* tp_as_hash */
	0,0,0,0,0,0,
	0,																			/* tp_doc */ 
	0,0,0,0,0,0,
	BPy_World_methods,										 /* tp_methods */
	0,																			/* tp_members */
};

/**
 * \defgroup World_Module Blender.World module functions
 *
 */

/*@{*/

/**
 * \brief Python module function: Blender.World.New()
 *
 * This is the .New() function of the Blender.World submodule. It creates
 * new World Data in Blender and returns its Python wrapper object.  The
 * name parameter is mandatory.
 * \param <name> - string: The World Data name.
 * \return A new World PyObject.
 */

static PyObject *M_World_New(PyObject *self, PyObject *args, PyObject *kwords)
{

	World *add_world(char *name);
	char*name = NULL;
	BPy_World		 *pyworld;
	World			 *blworld;

	if (!PyArg_ParseTuple(args, "s", &name))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,
					       "expected	int argument"));


	blworld = add_world(name);

	if (blworld){
	  /* return user count to zero because add_world() inc'd it */
	  blworld->id.us = 0;
	  /* create python wrapper obj */
	  pyworld = (BPy_World *)PyObject_NEW(BPy_World, &World_Type);
	}
	else
		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't create World Data in Blender"));

	if (pyworld == NULL)
		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
																	 "couldn't create World Data object"));

	pyworld->world = blworld; 

	return (PyObject *)pyworld;
}

/**
 * \brief Python module function: Blender.World.Get()
 *
 * This is the .Get() function of the Blender.World submodule.	It searches
 * the list of current World Data objects and returns a Python wrapper for
 * the one with the name provided by the user.	If called with no arguments,
 * it returns a list of all current World Data object names in Blender.
 * \param <name> - string: The name of an existing Blender World Data object.
 * \return () - A list with the names of all current World Data objects;\n
 * \return (name) - A Python wrapper for the World Data called 'name'
 * in Blender.
 */

static PyObject *M_World_Get(PyObject *self, PyObject *args)
{

	char	 *name = NULL;
	World *world_iter;
	PyObject *worldlist;
	BPy_World *wanted_world = NULL;
	char error_msg[64];

	if (!PyArg_ParseTuple(args, "|s", &name))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,
																	 "expected string argument (or nothing)"));

	world_iter = G.main->world.first;

	if (name) { /* (name) - Search world by name */
		while ((world_iter) && (wanted_world == NULL)) {
			if (strcmp (name, world_iter->id.name+2) == 0) {
				wanted_world = (BPy_World *)PyObject_NEW(BPy_World, &World_Type);
				if (wanted_world) wanted_world->world = world_iter;
			}
			world_iter = world_iter->id.next;
		}

		if (wanted_world == NULL) { /* Requested world doesn't exist */
			PyOS_snprintf(error_msg, sizeof(error_msg),
										"World \"%s\" not found", name);
			return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
		}

		return (PyObject *)wanted_world;
	}

	else { /* return a list of all worlds in the scene */
		worldlist = PyList_New (0);
		if (worldlist == NULL)
			return (EXPP_ReturnPyObjError (PyExc_MemoryError,
																			 "couldn't create PyList"));

		while (world_iter) {
			BPy_World *found_world = (BPy_World *)PyObject_NEW(BPy_World, &World_Type);
			found_world->world = world_iter;
			PyList_Append (worldlist ,	(PyObject *)found_world); 

			world_iter = world_iter->id.next;
		}
		return (worldlist);
	}

}



static PyObject *M_World_GetActive(PyObject *self)
{
	BPy_World *w = NULL;
	if(!G.scene->world)
		{
			Py_INCREF(Py_None);
			return Py_None;
		}
	w = (BPy_World *)PyObject_NEW(BPy_World, &World_Type);
	w->world = G.scene->world;
	return (PyObject *)w;
}

/*@}*/

/**
 * \brief Initializes the Blender.World submodule
 *
 * This function is used by Blender_Init() in Blender.c to register the
 * Blender.World submodule in the main Blender module.
 * \return PyObject*: The initialized submodule.
 */

PyObject *World_Init (void)
{
	PyObject	*submodule;

	World_Type.ob_type = &PyType_Type;

	submodule = Py_InitModule3("Blender.World",
									M_World_methods, M_World_doc);

	return (submodule);
}


/*****************************************************************************/
/* Python BPy_World methods:																								*/
/*****************************************************************************/
static PyObject *World_getRange(BPy_World *self)
{
    return PyFloat_FromDouble(self->world->range);
}

static PyObject *World_setRange(BPy_World *self, PyObject *args)
{
      float range=0.f;
      if (!PyArg_ParseTuple(args, "f", &range))
              return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected a float argument"));
    self->world->range = range;
    Py_INCREF(Py_None);
    return Py_None;
}


static PyObject *World_getIpo(BPy_World *self)
{
	struct Ipo *ipo = self->world->ipo;

	if (!ipo) {
		Py_INCREF (Py_None);
		return Py_None;
	}

	return Ipo_CreatePyObject (ipo);
}

static PyObject *World_setIpo(BPy_World *self, PyObject *args)
{
	PyObject *pyipo = 0;
	Ipo *ipo = NULL;
	Ipo *oldipo;

	if (!PyArg_ParseTuple(args, "O!", &Ipo_Type, &pyipo))
		return EXPP_ReturnPyObjError (PyExc_TypeError, "expected Ipo as argument");

	ipo = Ipo_FromPyObject(pyipo);

	if (!ipo) return EXPP_ReturnPyObjError (PyExc_RuntimeError, "null ipo!");

	if (ipo->blocktype != ID_CA)
		return EXPP_ReturnPyObjError (PyExc_TypeError,
			"this ipo is not a World type ipo");

	oldipo = self->world->ipo;
	if (oldipo) {
		ID *id = &oldipo->id;
		if (id->us > 0) id->us--;
	}

	((ID *)&ipo->id)->us++;

	self->world->ipo = ipo;

	Py_INCREF(Py_None);
	return Py_None;
}

static PyObject *World_clearIpo(BPy_World *self)
{
	World *world = self->world;
	Ipo *ipo = (Ipo *)world->ipo;

	if (ipo) {
		ID *id = &ipo->id;
		if (id->us > 0) id->us--;
		world->ipo = NULL;

		Py_INCREF (Py_True);
		return Py_True;
	}

	Py_INCREF (Py_False); /* no ipo found */
	return Py_False;
}

/**
 * \brief World PyMethod getName
 *
 * \return string: The World Data name.
 */

static PyObject *World_getName(BPy_World *self)
{
	PyObject *attr = PyString_FromString(self->world->id.name+2);

	if (attr) return attr;

	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get World.name attribute"));
}
/**
 * \brief World PyMethod setName
 * \param name - string: The new World Data name.
 */

static PyObject *World_setName(BPy_World *self, PyObject *args)
{
	char *name = 0;
	char buf[21];
	if (!PyArg_ParseTuple(args, "s", &name))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected string argument"));
	snprintf(buf, sizeof(buf), "%s", name);
	rename_id(&self->world->id, buf);

	Py_INCREF(Py_None);
	return Py_None;
}





/**
 * \brief World PyMethod getSkytype
 *
 * \return int : The World Data skytype.
 */

static PyObject *World_getSkytype(BPy_World *self)
{
	PyObject *attr = PyInt_FromLong((long)self->world->skytype);

	if (attr) return attr;

	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get World.skytype attribute"));
}


/**
 * \brief World PyMethod setSkytype
 *
 * \return int : The World Data skytype.
 */

static PyObject *World_setSkytype(BPy_World *self, PyObject *args )
{
	int skytype;

	if (!PyArg_ParseTuple(args, "i", &skytype))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,
																		 "expected int argument"));
	self->world->skytype = skytype;
	Py_INCREF(Py_None);
	return Py_None;
}


/**
 * \brief World PyMethod getMode
 *
 * \return int : The World Data mode.
 */

static PyObject *World_getMode(BPy_World *self)
{
	PyObject *attr = PyInt_FromLong((long)self->world->mode);

	if (attr) return attr;

	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get World.mode attribute"));
}


/**
 * \brief World PyMethod setMode
 *
 * \return int : The World Data mode.
 */

static PyObject *World_setMode(BPy_World *self, PyObject *args )
{
	int mode;

	if (!PyArg_ParseTuple(args, "i", &mode))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,
																		 "expected int argument"));
	self->world->mode = mode;
	Py_INCREF(Py_None);
	return Py_None;
}














/**
 * \brief World PyMethod getMistype
 *
 * \return int : The World Data mistype.
 */

static PyObject *World_getMistype(BPy_World *self)
{
	PyObject *attr = PyInt_FromLong((long)self->world->mistype);

	if (attr) return attr;

	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get World.mistype attribute"));
}


/**
 * \brief World PyMethod setMistype
 *
 * \return int : The World Data mistype.
 */

static PyObject *World_setMistype(BPy_World *self, PyObject *args )
{
	int mistype;

	if (!PyArg_ParseTuple(args, "i", &mistype))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,
																		 "expected int argument"));
	self->world->mistype = mistype;
	Py_INCREF(Py_None);
	return Py_None;
}





static PyObject *World_getHor(BPy_World *self)
{
	PyObject *attr = PyList_New(0);
	if (!attr)
		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't create list"));
	PyList_Append(attr, PyFloat_FromDouble(self->world->horr));
	PyList_Append(attr, PyFloat_FromDouble(self->world->horg));
	PyList_Append(attr, PyFloat_FromDouble(self->world->horb));
	return attr;
}


static PyObject *World_setHor(BPy_World *self, PyObject *args )
{
	PyObject *listargs=0;
	if (!PyArg_ParseTuple(args, "O", &listargs))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,
																	 "expected list argument"));
	self->world->horr =  PyFloat_AsDouble(PyList_GetItem(listargs,0));
	self->world->horg =  PyFloat_AsDouble(PyList_GetItem(listargs,1));
	self->world->horb = PyFloat_AsDouble(PyList_GetItem(listargs,2));
	Py_INCREF(Py_None);
	return Py_None;
}


static PyObject *World_getZen(BPy_World *self)
{
	PyObject *attr = PyList_New(0);
	if (!attr)
		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't create list"));
	PyList_Append(attr, PyFloat_FromDouble(self->world->zenr));
	PyList_Append(attr, PyFloat_FromDouble(self->world->zeng));
	PyList_Append(attr, PyFloat_FromDouble(self->world->zenb));
	return attr;
}


static PyObject *World_setZen(BPy_World *self, PyObject *args )
{
	PyObject *listargs=0;
	if (!PyArg_ParseTuple(args, "O", &listargs))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,
																	 "expected list argument"));
	self->world->zenr =  PyFloat_AsDouble(PyList_GetItem(listargs,0));
	self->world->zeng =  PyFloat_AsDouble(PyList_GetItem(listargs,1));
	self->world->zenb = PyFloat_AsDouble(PyList_GetItem(listargs,2));
	Py_INCREF(Py_None);
	return Py_None;
}




static PyObject *World_getAmb(BPy_World *self)
{
	PyObject *attr = PyList_New(0);
	if (!attr)
		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't create list"));
	PyList_Append(attr, PyFloat_FromDouble(self->world->ambr));
	PyList_Append(attr, PyFloat_FromDouble(self->world->ambg));
	PyList_Append(attr, PyFloat_FromDouble(self->world->ambb));
	return attr;
}


static PyObject *World_setAmb(BPy_World *self, PyObject *args )
{
	PyObject *listargs=0;
	if (!PyArg_ParseTuple(args, "O", &listargs))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument"));
	if (!PyList_Check(listargs))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument"));
	if (PyList_Size(listargs)!=3)
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"wrong list size"));
	self->world->ambr =  PyFloat_AsDouble(PyList_GetItem(listargs,0));
	self->world->ambg =  PyFloat_AsDouble(PyList_GetItem(listargs,1));
	self->world->ambb = PyFloat_AsDouble(PyList_GetItem(listargs,2));
	Py_INCREF(Py_None);
	return Py_None;
}


static PyObject *World_getStar(BPy_World *self)
{
	PyObject *attr = PyList_New(0);
	if (!attr)
		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,"couldn't create list"));
	PyList_Append(attr, PyFloat_FromDouble(self->world->starr));
	PyList_Append(attr, PyFloat_FromDouble(self->world->starg));
	PyList_Append(attr, PyFloat_FromDouble(self->world->starb));
	PyList_Append(attr, PyFloat_FromDouble(self->world->starsize));
	PyList_Append(attr, PyFloat_FromDouble(self->world->starmindist));
	PyList_Append(attr, PyFloat_FromDouble(self->world->stardist));
	PyList_Append(attr, PyFloat_FromDouble(self->world->starcolnoise));
	return attr;
}


static PyObject *World_setStar(BPy_World *self, PyObject *args )
{
	PyObject *listargs=0;
	if (!PyArg_ParseTuple(args, "O", &listargs))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument"));
	if (!PyList_Check(listargs))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument"));
	if (PyList_Size(listargs)!=7)
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"wrong list size"));
	self->world->starr =	PyFloat_AsDouble(PyList_GetItem(listargs,0));
	self->world->starg =	PyFloat_AsDouble(PyList_GetItem(listargs,1));
	self->world->starb = PyFloat_AsDouble(PyList_GetItem(listargs,2));
	self->world->starsize = PyFloat_AsDouble(PyList_GetItem(listargs,3));
	self->world->starmindist = PyFloat_AsDouble(PyList_GetItem(listargs,4));
	self->world->stardist = PyFloat_AsDouble(PyList_GetItem(listargs,5));
	self->world->starcolnoise = PyFloat_AsDouble(PyList_GetItem(listargs,6));
	Py_INCREF(Py_None);
	return Py_None;
}






static PyObject *World_getMist(BPy_World *self)
{
	PyObject *attr = PyList_New(0);
	if (!attr)
		return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create list"));
	PyList_Append(attr, PyFloat_FromDouble(self->world->misi));
	PyList_Append(attr, PyFloat_FromDouble(self->world->miststa));
	PyList_Append(attr, PyFloat_FromDouble(self->world->mistdist));
	PyList_Append(attr, PyFloat_FromDouble(self->world->misthi));
	return attr;
}


static PyObject *World_setMist(BPy_World *self, PyObject *args )
{
	PyObject *listargs=0;
	if (!PyArg_ParseTuple(args, "O", &listargs))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument"));
	if (!PyList_Check(listargs))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument"));
	if (PyList_Size(listargs)!=4)
		return (EXPP_ReturnPyObjError (PyExc_TypeError,"wrong list size"));
	self->world->misi =  PyFloat_AsDouble(PyList_GetItem(listargs,0));
	self->world->miststa =	PyFloat_AsDouble(PyList_GetItem(listargs,1));
	self->world->mistdist =  PyFloat_AsDouble(PyList_GetItem(listargs,2));
	self->world->misthi = PyFloat_AsDouble(PyList_GetItem(listargs,3));
	Py_INCREF(Py_None);
	return Py_None;
}

/* world.addScriptLink */
static PyObject *World_addScriptLink (BPy_World *self, PyObject *args)
{
	World *world = self->world;
	ScriptLink *slink = NULL;

	slink = &(world)->scriptlink;

	if (!EXPP_addScriptLink(slink, args, 0))
		return EXPP_incr_ret (Py_None);
	else return NULL;
}

/* world.clearScriptLinks */
static PyObject *World_clearScriptLinks (BPy_World *self)
{
	World *world = self->world;
	ScriptLink *slink = NULL;

	slink = &(world)->scriptlink;

	return EXPP_incr_ret(Py_BuildValue("i", EXPP_clearScriptLinks (slink)));
}

/* world.getScriptLinks */
static PyObject *World_getScriptLinks (BPy_World *self, PyObject *args)
{
	World *world = self->world;
	ScriptLink *slink = NULL;
	PyObject *ret = NULL;

	slink = &(world)->scriptlink;

	ret = EXPP_getScriptLinks(slink, args, 0);

	if (ret) return ret;
	else return NULL;
}


/*@{*/

/**
 * \brief The World PyType destructor
 */

static void World_DeAlloc (BPy_World *self)
{
	PyObject_DEL (self);
}

/**
 * \brief The World PyType attribute getter
 *
 * This is the callback called when a user tries to retrieve the contents of
 * World PyObject data members.  Ex. in Python: "print myworld.lens".
 */

static PyObject *World_GetAttr (BPy_World *self, char *name)
{

if (strcmp (name, "name") == 0)return  World_getName (self);
if (strcmp (name, "skytype") == 0)return	World_getSkytype (self);
if (strcmp (name, "mode") == 0)return  World_getMode (self);
if (strcmp (name, "mistype") == 0)return	World_getMistype (self);
if (strcmp (name, "hor") == 0)return	World_getHor (self);
if (strcmp (name, "zen") == 0)return	World_getZen (self);
if (strcmp (name, "amb") == 0)return	World_getAmb (self);
if (strcmp (name, "star") == 0)return  World_getStar (self);
if (strcmp (name, "mist") == 0)return  World_getMist (self);
	return Py_FindMethod(BPy_World_methods, (PyObject *)self, name);
}

/**
 * \brief The World PyType attribute setter
 *
 * This is the callback called when the user tries to change the value of some
 * World data member.  Ex. in Python: "myworld.lens = 45.0".
 */

static int World_SetAttr (BPy_World *self, char *name, PyObject *value)
{
	PyObject *valtuple	= Py_BuildValue("(O)", value);

	if (!valtuple) 
		return EXPP_ReturnIntError(PyExc_MemoryError,
															 "WorldSetAttr: couldn't parse args");
		if (strcmp (name, "name") == 0) World_setName (self,valtuple);
if (strcmp (name, "skytype") == 0) World_setSkytype (self,valtuple);
if (strcmp (name, "mode") == 0) World_setMode (self,valtuple);
if (strcmp (name, "mistype") == 0) World_setMistype (self,valtuple);
if (strcmp (name, "hor") == 0) World_setHor (self,valtuple);
if (strcmp (name, "zen") == 0) World_setZen (self,valtuple);
if (strcmp (name, "amb") == 0) World_setAmb (self,valtuple);
if (strcmp (name, "star") == 0) World_setStar (self,valtuple);
if (strcmp (name, "mist") == 0) World_setMist (self,valtuple);
return 0; /* normal exit */
}

/**
 * \brief The World PyType compare function
 *
 * This function compares two given World PyObjects, returning 0 for equality
 * and -1 otherwise.	In Python it becomes 1 if they are equal and 0 case not.
 * The comparison is done with their pointers to Blender World Data objects,
 * so any two wrappers pointing to the same Blender World Data will be
 * considered the same World PyObject.	Currently, only the "==" and "!="
 * comparisons are meaninful -- the "<", "<=", ">" or ">=" are not.
 */

static int World_Compare (BPy_World *a, BPy_World *b)
{
	World *pa = a->world, *pb = b->world;
	return (pa == pb) ? 0:-1;
}

/**
 * \brief The World PyType print callback
 *
 * This function is called when the user tries to print a PyObject of type
 * World.  It builds a string with the name of the wrapped Blender World.
 */

/*
static int World_Print(BPy_World *self, FILE *fp, int flags)
{ 
	fprintf(fp, "[World \"%s\"]", self->world->id.name+2);
	return 0;
}
*/

/**
 * \brief The World PyType repr callback
 *
 * This function is called when the statement "repr(myworld)" is executed in
 * Python.	Repr gives a string representation of a PyObject.
 */

static PyObject *World_Repr (BPy_World *self)
{
	return PyString_FromFormat("[World \"%s\"]", self->world->id.name+2);
}

/*@}*/
/*
static int World_compare (BPy_World *a, BPy_World *b)
{
	World *pa = a->world, *pb = b->world;
	return (pa == pb) ? 0:-1;
}
*/
PyObject* World_CreatePyObject (struct World *world)
{
 BPy_World		* blen_object;

		blen_object = (BPy_World*)PyObject_NEW (BPy_World, &World_Type);

		if (blen_object == NULL)
		{
				return (NULL);
		}
		blen_object->world = world;
		return ((PyObject*)blen_object);

}

int World_CheckPyObject (PyObject *py_obj)
{
return (py_obj->ob_type == &World_Type);
}


World* World_FromPyObject (PyObject *py_obj)
{
 BPy_World		* blen_obj;

		blen_obj = (BPy_World*)py_obj;
		return (blen_obj->world);

}

/*****************************************************************************/
/* Description: Returns the object with the name specified by the argument	 */
/*							name. Note that the calling function has to remove the first */
/*							two characters of the object name. These two characters			 */
/*							specify the type of the object (OB, ME, WO, ...)						 */
/*							The function will return NULL when no object with the given  */
/*							name is found.																							 */
/*****************************************************************************/
World * GetWorldByName (char * name)
{
	World	* world_iter;

	world_iter = G.main->world.first;
	while (world_iter)
	{
		if (StringEqual (name, GetIdName (&(world_iter->id))))
		{
			return (world_iter);
		}
		world_iter = world_iter->id.next;
	}

	/* There is no object with the given name */
	return (NULL);
}

