BGE: Add new world API KX_WorldInfo (KX_Scene)

This Patch will add a the world API (mist, background, ambient)  to KX_WorldInfo.
The new API uses now attributes.

Reviewers: campbellbarton, moguri

Reviewed By: moguri

Subscribers: klauser, brecht

Differential Revision: https://developer.blender.org/D157

6 files changed, 352 insertions, 5 deletions

diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index 8fd38db4a2a..b3fba745e96 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -1039,6 +1039,7 @@ static PyObject *gPySetBackgroundColor(PyObject *, PyObject *value)
 		return NULL;
 	}
 
+	ShowDeprecationWarning("setBackgroundColor()", "KX_WorldInfo.background_color");
 	wi->setBackColor((float)vec[0], (float)vec[1], (float)vec[2]);
 
 	Py_RETURN_NONE;
@@ -1056,6 +1057,7 @@ static PyObject *gPySetMistColor(PyObject *, PyObject *value)
 		return NULL;
 	}
 
+	ShowDeprecationWarning("setMistColor()", "KX_WorldInfo.mist_color");
 	wi->setMistColor((float)vec[0], (float)vec[1], (float)vec[2]);
 
 	Py_RETURN_NONE;
@@ -1068,7 +1070,7 @@ static PyObject *gPyDisableMist(PyObject *)
 		PyErr_SetString(PyExc_RuntimeError, "bge.render.DisableMist(), World not available");
 		return NULL;
 	}
-	ShowDeprecationWarning("DisableMist()", "setUseMist(false)");
+	ShowDeprecationWarning("DisableMist()", "KX_WorldInfo.mist_enable = False");
 	wi->setUseMist(false);
 
 	Py_RETURN_NONE;
@@ -1086,6 +1088,7 @@ static PyObject *gPySetUseMist(PyObject *, PyObject *args)
 		return NULL;
 	}
 
+	ShowDeprecationWarning("setUseMist()", "KX_WorldInfo.mist_enable");
 	wi->setUseMist(enable);
 
 	Py_RETURN_NONE;
@@ -1109,6 +1112,7 @@ static PyObject *gPySetMistType(PyObject *, PyObject *args)
 		return NULL;
 	}
 
+	ShowDeprecationWarning("setMistType()", "KX_WorldInfo.mist_type");
 	wi->setMistType(type);
 
 	Py_RETURN_NONE;
@@ -1126,6 +1130,7 @@ static PyObject *gPySetMistStart(PyObject *, PyObject *args)
 		return NULL;
 	}
 
+	ShowDeprecationWarning("setMistStart()", "KX_WorldInfo.mist_start");
 	wi->setMistStart(miststart);
 
 	Py_RETURN_NONE;
@@ -1143,6 +1148,7 @@ static PyObject *gPySetMistEnd(PyObject *, PyObject *args)
 		return NULL;
 	}
 
+	ShowDeprecationWarning("setMistEnd()", "KX_WorldInfo.mist_distance");
 	wi->setMistDistance(mistdist);
 
 	Py_RETURN_NONE;
@@ -1161,6 +1167,7 @@ static PyObject *gPySetMistIntensity(PyObject *, PyObject *args)
 		return NULL;
 	}
 
+	ShowDeprecationWarning("setMistIntensity()", "KX_WorldInfo.mist_intensity");
 	wi->setMistIntensity(intensity);
 
 	Py_RETURN_NONE;
@@ -1178,6 +1185,7 @@ static PyObject *gPySetAmbientColor(PyObject *, PyObject *value)
 		return NULL;
 	}
 
+	ShowDeprecationWarning("setAmbientColor()", "KX_WorldInfo.ambient_color");
 	wi->setAmbientColor((float)vec[0], (float)vec[1], (float)vec[2]);
 
 	Py_RETURN_NONE;
diff --git a/source/gameengine/Ketsji/KX_PythonInitTypes.cpp b/source/gameengine/Ketsji/KX_PythonInitTypes.cpp
index 828fd62f205..b3511e4e61a 100644
--- a/source/gameengine/Ketsji/KX_PythonInitTypes.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInitTypes.cpp
@@ -40,6 +40,7 @@
 #include "BL_ArmatureConstraint.h"
 #include "BL_ArmatureObject.h"
 #include "BL_ArmatureChannel.h"
+#include "KX_WorldInfo.h"
 #include "KX_ArmatureSensor.h"
 #include "KX_BlenderMaterial.h"
 #include "KX_CameraActuator.h"
@@ -231,6 +232,7 @@ PyMODINIT_FUNC initGameTypesPythonBinding(void)
 		PyType_Ready_Attr(dict, KX_SCA_EndObjectActuator, init_getset);
 		PyType_Ready_Attr(dict, KX_SCA_ReplaceMeshActuator, init_getset);
 		PyType_Ready_Attr(dict, KX_Scene, init_getset);
+		PyType_Ready_Attr(dict, KX_WorldInfo, init_getset);
 		PyType_Ready_Attr(dict, KX_NavMeshObject, init_getset);
 		PyType_Ready_Attr(dict, KX_SceneActuator, init_getset);
 		PyType_Ready_Attr(dict, KX_SoundActuator, init_getset);
@@ -279,6 +281,7 @@ PyMODINIT_FUNC initGameTypesPythonBinding(void)
 	/* Init mathutils callbacks */
 	KX_GameObject_Mathutils_Callback_Init();
 	KX_ObjectActuator_Mathutils_Callback_Init();
+	KX_WorldInfo_Mathutils_Callback_Init();
 #endif
 
 	return m;
diff --git a/source/gameengine/Ketsji/KX_Scene.cpp b/source/gameengine/Ketsji/KX_Scene.cpp
index e26fdaa4898..193a72ebd2a 100644
--- a/source/gameengine/Ketsji/KX_Scene.cpp
+++ b/source/gameengine/Ketsji/KX_Scene.cpp
@@ -2341,6 +2341,19 @@ PyObject *KX_Scene::pyattr_get_lights(void *self_v, const KX_PYATTRIBUTE_DEF *at
 	return self->GetLightList()->GetProxy();
 }
 
+PyObject *KX_Scene::pyattr_get_world(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+	KX_Scene* self = static_cast<KX_Scene*>(self_v);
+	KX_WorldInfo *world = self->GetWorldInfo();
+
+	if (world->GetName() != "") {
+		return world->GetProxy();
+	}
+	else {
+		Py_RETURN_NONE;
+	}
+}
+
 PyObject *KX_Scene::pyattr_get_cameras(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 {
 	/* With refcounts in this case...
@@ -2464,6 +2477,7 @@ PyAttributeDef KX_Scene::Attributes[] = {
 	KX_PYATTRIBUTE_RO_FUNCTION("objectsInactive",	KX_Scene, pyattr_get_objects_inactive),
 	KX_PYATTRIBUTE_RO_FUNCTION("lights",			KX_Scene, pyattr_get_lights),
 	KX_PYATTRIBUTE_RO_FUNCTION("cameras",			KX_Scene, pyattr_get_cameras),
+	KX_PYATTRIBUTE_RO_FUNCTION("world",				KX_Scene, pyattr_get_world),
 	KX_PYATTRIBUTE_RW_FUNCTION("active_camera",		KX_Scene, pyattr_get_active_camera, pyattr_set_active_camera),
 	KX_PYATTRIBUTE_RW_FUNCTION("pre_draw",			KX_Scene, pyattr_get_drawing_callback_pre, pyattr_set_drawing_callback_pre),
 	KX_PYATTRIBUTE_RW_FUNCTION("post_draw",			KX_Scene, pyattr_get_drawing_callback_post, pyattr_set_drawing_callback_post),
diff --git a/source/gameengine/Ketsji/KX_Scene.h b/source/gameengine/Ketsji/KX_Scene.h
index a031be78e92..93e764851a9 100644
--- a/source/gameengine/Ketsji/KX_Scene.h
+++ b/source/gameengine/Ketsji/KX_Scene.h
@@ -624,6 +624,7 @@ public:
 	static PyObject*	pyattr_get_objects_inactive(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
 	static PyObject*	pyattr_get_lights(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
 	static PyObject*	pyattr_get_cameras(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	static PyObject*	pyattr_get_world(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
 	static PyObject*	pyattr_get_active_camera(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
 	static int			pyattr_set_active_camera(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
 	static PyObject*	pyattr_get_drawing_callback_pre(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
diff --git a/source/gameengine/Ketsji/KX_WorldInfo.cpp b/source/gameengine/Ketsji/KX_WorldInfo.cpp
index a094bffd77a..b07aa26cf91 100644
--- a/source/gameengine/Ketsji/KX_WorldInfo.cpp
+++ b/source/gameengine/Ketsji/KX_WorldInfo.cpp
@@ -32,6 +32,8 @@
 
 #include "KX_WorldInfo.h"
 #include "KX_PythonInit.h"
+#include "KX_PyMath.h"
+#include "RAS_IRasterizer.h"
 #include "GPU_material.h"
 
 /* This little block needed for linking to Blender... */
@@ -53,6 +55,7 @@
 KX_WorldInfo::KX_WorldInfo(Scene *blenderscene, World *blenderworld)
 {
 	if (blenderworld) {
+		m_name = blenderworld->id.name + 2;
 		m_do_color_management = BKE_scene_check_color_management_enabled(blenderscene);
 		m_hasworld = true;
 		m_hasmist = ((blenderworld->mode) & WO_MIST ? true : false);
@@ -73,6 +76,11 @@ KX_WorldInfo::~KX_WorldInfo()
 {
 }
 
+const STR_String& KX_WorldInfo::GetName()
+{
+	return m_name;
+}
+
 bool KX_WorldInfo::hasWorld()
 {
 	return m_hasworld;
@@ -248,3 +256,298 @@ void KX_WorldInfo::UpdateWorldSettings()
 		}
 	}
 }
+
+#ifdef WITH_PYTHON
+
+/* -------------------------------------------------------------------------
+ * Python functions
+ * ------------------------------------------------------------------------- */
+PyObject *KX_WorldInfo::py_repr(void)
+{
+	return PyUnicode_From_STR_String(GetName());
+}
+
+/* -------------------------------------------------------------------------
+ * Python Integration Hooks
+ * ------------------------------------------------------------------------- */
+PyTypeObject KX_WorldInfo::Type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"KX_WorldInfo",
+	sizeof(PyObjectPlus_Proxy),
+	0,
+	py_base_dealloc,
+	0,
+	0,
+	0,
+	0,
+	py_base_repr,
+	0,0,0,0,0,0,0,0,0,
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	0,0,0,0,0,0,0,
+	Methods,
+	0,
+	0,
+	&PyObjectPlus::Type,
+	0,0,0,0,0,0,
+	py_base_new
+};
+
+PyMethodDef KX_WorldInfo::Methods[] = {
+	{NULL,NULL} /* Sentinel */
+};
+
+PyAttributeDef KX_WorldInfo::Attributes[] = {
+	KX_PYATTRIBUTE_BOOL_RW("mist_enable", KX_WorldInfo, m_hasmist),
+	KX_PYATTRIBUTE_FLOAT_RW("mist_start", 0.0f, 10000.0f, KX_WorldInfo, m_miststart),
+	KX_PYATTRIBUTE_FLOAT_RW("mist_distance", 0.001f, 10000.0f, KX_WorldInfo, m_mistdistance),
+	KX_PYATTRIBUTE_FLOAT_RW("mist_intensity", 0.0f, 1.0f, KX_WorldInfo, m_mistintensity),
+	KX_PYATTRIBUTE_SHORT_RW("mist_type", 0, 2, true, KX_WorldInfo, m_misttype),
+	KX_PYATTRIBUTE_RO_FUNCTION("KX_MIST_QUADRATIC", KX_WorldInfo, pyattr_get_mist_typeconst),
+	KX_PYATTRIBUTE_RO_FUNCTION("KX_MIST_LINEAR", KX_WorldInfo, pyattr_get_mist_typeconst),
+	KX_PYATTRIBUTE_RO_FUNCTION("KX_MIST_INV_QUADRATIC", KX_WorldInfo, pyattr_get_mist_typeconst),
+	KX_PYATTRIBUTE_RW_FUNCTION("mist_color", KX_WorldInfo, pyattr_get_mist_color, pyattr_set_mist_color),
+	KX_PYATTRIBUTE_RW_FUNCTION("background_color", KX_WorldInfo, pyattr_get_back_color, pyattr_set_back_color),
+	KX_PYATTRIBUTE_RW_FUNCTION("ambient_color", KX_WorldInfo, pyattr_get_ambient_color, pyattr_set_ambient_color),
+	{ NULL } /* Sentinel */
+};
+
+/* Attribute get/set functions */
+
+#ifdef USE_MATHUTILS
+
+/*----------------------mathutils callbacks ----------------------------*/
+
+/* subtype */
+#define MATHUTILS_VEC_CB_MIST_COLOR 1
+#define MATHUTILS_VEC_CB_BACK_COLOR 2
+#define MATHUTILS_VEC_CB_AMBIENT_COLOR 3
+
+static unsigned char mathutils_world_vector_cb_index = -1; /* index for our callbacks */
+
+static int mathutils_world_generic_check(BaseMathObject *bmo)
+{
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>BGE_PROXY_REF(bmo->cb_user);
+	if (self == NULL)
+		return -1;
+		
+	return 0;
+}
+
+static int mathutils_world_vector_get(BaseMathObject *bmo, int subtype)
+{
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>BGE_PROXY_REF(bmo->cb_user);
+	if (self == NULL)
+		return -1;
+
+	switch (subtype) {
+		case MATHUTILS_VEC_CB_MIST_COLOR:
+			copy_v3_v3(bmo->data, self->m_mistcolor);
+			break;
+		case MATHUTILS_VEC_CB_BACK_COLOR:
+			copy_v3_v3(bmo->data, self->m_backgroundcolor);
+			break;
+		case MATHUTILS_VEC_CB_AMBIENT_COLOR:
+			copy_v3_v3(bmo->data, self->m_ambientcolor);
+			break;
+	default:
+		return -1;
+	}
+	return 0;
+}
+
+static int mathutils_world_vector_set(BaseMathObject *bmo, int subtype)
+{
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>BGE_PROXY_REF(bmo->cb_user);
+
+	if (self == NULL)
+		return -1;
+
+	switch (subtype) {
+		case MATHUTILS_VEC_CB_MIST_COLOR:
+			self->setMistColor(bmo->data[0], bmo->data[1], bmo->data[2]);
+			break;
+		case MATHUTILS_VEC_CB_BACK_COLOR:
+			self->setBackColor(bmo->data[0], bmo->data[1], bmo->data[2]);
+			break;
+		case MATHUTILS_VEC_CB_AMBIENT_COLOR:
+			self->setAmbientColor(bmo->data[0], bmo->data[1], bmo->data[2]);
+			break;
+	default:
+		return -1;
+	}
+	return 0;
+}
+
+static int mathutils_world_vector_get_index(BaseMathObject *bmo, int subtype, int index)
+{
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>BGE_PROXY_REF(bmo->cb_user);
+
+	if (self == NULL)
+		return -1;
+
+	switch (subtype) {
+		case MATHUTILS_VEC_CB_MIST_COLOR:
+		{
+			const float *color = self->m_mistcolor;
+			bmo->data[index] = color[index];
+		}
+		break;
+		case MATHUTILS_VEC_CB_BACK_COLOR:
+		{
+			const float *color = self->m_backgroundcolor;
+			bmo->data[index] = color[index];
+		}
+			break;
+		case MATHUTILS_VEC_CB_AMBIENT_COLOR:
+		{
+			const float *color = self->m_ambientcolor;
+			bmo->data[index] = color[index];
+		}
+		break;
+	default:
+		return -1;
+	}
+	return 0;
+}
+
+static int mathutils_world_vector_set_index(BaseMathObject *bmo, int subtype, int index)
+{
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>BGE_PROXY_REF(bmo->cb_user);
+
+	if (self == NULL)
+		return -1;
+
+	float color[4];
+	switch (subtype) {
+		case MATHUTILS_VEC_CB_MIST_COLOR:
+			copy_v3_v3(color, self->m_mistcolor);
+			color[index] = bmo->data[index];
+			self->setMistColor(color[0], color[1], color[2]);
+		break;
+		case MATHUTILS_VEC_CB_BACK_COLOR:
+			copy_v3_v3(color, self->m_backgroundcolor);
+			color[index] = bmo->data[index];
+			self->setBackColor(color[0], color[1], color[2]);
+		break;
+		case MATHUTILS_VEC_CB_AMBIENT_COLOR:
+			copy_v3_v3(color, self->m_ambientcolor);
+			color[index] = bmo->data[index];
+			self->setAmbientColor(color[0], color[1], color[2]);
+			break;
+	default:
+		return -1;
+	}
+	return 0;
+}
+
+static Mathutils_Callback mathutils_world_vector_cb = {
+	mathutils_world_generic_check,
+	mathutils_world_vector_get,
+	mathutils_world_vector_set,
+	mathutils_world_vector_get_index,
+	mathutils_world_vector_set_index
+};
+
+void KX_WorldInfo_Mathutils_Callback_Init()
+{
+	// register mathutils callbacks, ok to run more than once.
+	mathutils_world_vector_cb_index = Mathutils_RegisterCallback(&mathutils_world_vector_cb);
+}
+#endif // USE_MATHUTILS
+
+
+PyObject *KX_WorldInfo::pyattr_get_mist_typeconst(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+	PyObject *retvalue;
+
+	const char* type = attrdef->m_name;
+
+	if (!strcmp(type, "KX_MIST_QUADRATIC")) {
+		retvalue = PyLong_FromLong(KX_MIST_QUADRATIC);
+	} 
+	else if (!strcmp(type, "KX_MIST_LINEAR")) {
+		retvalue = PyLong_FromLong(KX_MIST_LINEAR);
+	} 
+	else if (!strcmp(type, "KX_MIST_INV_QUADRATIC")) {
+		retvalue = PyLong_FromLong(KX_MIST_INV_QUADRATIC);
+	}
+	else {
+		/* should never happen */
+		PyErr_SetString(PyExc_TypeError, "invalid mist type");
+		retvalue = NULL;
+	}
+
+	return retvalue;
+}
+
+PyObject *KX_WorldInfo::pyattr_get_mist_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+#ifdef USE_MATHUTILS
+	return Vector_CreatePyObject_cb(BGE_PROXY_FROM_REF(self_v), 3, mathutils_world_vector_cb_index, MATHUTILS_VEC_CB_MIST_COLOR);
+#else
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>(self_v);
+	return PyObjectFrom(MT_Vector3(self->m_mistcolor));
+#endif
+}
+
+int KX_WorldInfo::pyattr_set_mist_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>(self_v);
+
+	MT_Vector3 color;
+	if (PyVecTo(value, color))
+	{
+		self->setMistColor(color[0], color[1], color[2]);
+		return PY_SET_ATTR_SUCCESS;
+	}
+	return PY_SET_ATTR_FAIL;
+}
+
+PyObject *KX_WorldInfo::pyattr_get_back_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+
+#ifdef USE_MATHUTILS
+	return Vector_CreatePyObject_cb(BGE_PROXY_FROM_REF(self_v), 3, mathutils_world_vector_cb_index, MATHUTILS_VEC_CB_BACK_COLOR);
+#else
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>(self_v);
+	return PyObjectFrom(MT_Vector3(self->m_backgroundcolor));
+#endif
+}
+
+int KX_WorldInfo::pyattr_set_back_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>(self_v);
+
+	MT_Vector3 color;
+	if (PyVecTo(value, color))
+	{
+		self->setBackColor(color[0], color[1], color[2]);
+		return PY_SET_ATTR_SUCCESS;
+	}
+	return PY_SET_ATTR_FAIL;
+}
+
+PyObject *KX_WorldInfo::pyattr_get_ambient_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+#ifdef USE_MATHUTILS
+	return Vector_CreatePyObject_cb(BGE_PROXY_FROM_REF(self_v), 3, mathutils_world_vector_cb_index, MATHUTILS_VEC_CB_AMBIENT_COLOR);
+#else
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>(self_v);
+	return PyObjectFrom(MT_Vector3(self->m_ambientcolor));
+#endif
+}
+
+int KX_WorldInfo::pyattr_set_ambient_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	KX_WorldInfo *self = static_cast<KX_WorldInfo*>(self_v);
+
+	MT_Vector3 color;
+	if (PyVecTo(value, color))
+	{
+		self->setAmbientColor(color[0], color[1], color[2]);
+		return PY_SET_ATTR_SUCCESS;
+	}
+	return PY_SET_ATTR_FAIL;
+}
+
+#endif /* WITH_PYTHON */
diff --git a/source/gameengine/Ketsji/KX_WorldInfo.h b/source/gameengine/Ketsji/KX_WorldInfo.h
index 4abcfb98892..830f12de6b0 100644
--- a/source/gameengine/Ketsji/KX_WorldInfo.h
+++ b/source/gameengine/Ketsji/KX_WorldInfo.h
@@ -34,19 +34,24 @@
 
 #include "MT_Scalar.h"
 #include "KX_KetsjiEngine.h"
-#include "RAS_IRasterizer.h"
+#include "PyObjectPlus.h"
 
 #ifdef WITH_CXX_GUARDEDALLOC
 #include "MEM_guardedalloc.h"
 #endif
 
+#ifdef USE_MATHUTILS
+void KX_WorldInfo_Mathutils_Callback_Init(void);
+#endif
+
 struct Scene;
 struct World;
-const class KX_KetsjiEngine;
-const class RAS_IRasterizer;
 
-class KX_WorldInfo
+class KX_WorldInfo : public PyObjectPlus
 {
+	Py_Header
+
+	STR_String m_name;
 	bool m_do_color_management;
 	bool m_hasworld;
 	bool m_hasmist;
@@ -74,6 +79,7 @@ public:
 	KX_WorldInfo(Scene *blenderscene, World *blenderworld);
 	~KX_WorldInfo();
 
+	const STR_String &GetName();
 	bool hasWorld();
 	bool hasMist();
 	short getMistType();
@@ -100,6 +106,18 @@ public:
 	void UpdateBackGround();
 	void UpdateWorldSettings();
 
+#ifdef WITH_PYTHON
+	/* attributes */
+	static PyObject *pyattr_get_mist_typeconst(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	static PyObject *pyattr_get_mist_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	static int pyattr_set_mist_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+	static PyObject *pyattr_get_back_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	static int pyattr_set_back_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+	static PyObject *pyattr_get_ambient_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	static int pyattr_set_ambient_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+	virtual PyObject *py_repr(void);
+#endif
+
 #ifdef WITH_CXX_GUARDEDALLOC
 	MEM_CXX_CLASS_ALLOC_FUNCS("GE:KX_WorldInfo")
 #endif