8 files changed, 390 insertions, 25 deletions

diff --git a/source/gameengine/Rasterizer/CMakeLists.txt b/source/gameengine/Rasterizer/CMakeLists.txt
index 879115add47..e254bf9b1c5 100644
--- a/source/gameengine/Rasterizer/CMakeLists.txt
+++ b/source/gameengine/Rasterizer/CMakeLists.txt
@@ -61,7 +61,7 @@ set(SRC
 	RAS_ICanvas.h
 	RAS_IPolygonMaterial.h
 	RAS_IRasterizer.h
-	RAS_LightObject.h
+	RAS_ILightObject.h
 	RAS_MaterialBucket.h
 	RAS_MeshObject.h
 	RAS_ObjectColor.h
diff --git a/source/gameengine/Rasterizer/RAS_LightObject.h b/source/gameengine/Rasterizer/RAS_ILightObject.h
index 79818def5f0..28c5d9aedd7 100644
--- a/source/gameengine/Rasterizer/RAS_LightObject.h
+++ b/source/gameengine/Rasterizer/RAS_ILightObject.h
@@ -20,7 +20,7 @@
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s): none yet.
+ * Contributor(s): Mitchell Stokes
  *
  * ***** END GPL LICENSE BLOCK *****
  */
@@ -32,10 +32,18 @@
 #ifndef __RAS_LIGHTOBJECT_H__
 #define __RAS_LIGHTOBJECT_H__
 
-#include "MT_CmMatrix4x4.h"
+class RAS_ICanvas;
 
-struct RAS_LightObject
+class KX_Camera;
+class KX_Scene;
+
+class MT_Transform;
+
+struct Image;
+
+class RAS_ILightObject
 {
+public:
 	enum LightType {
 		LIGHT_SPOT,
 		LIGHT_SUN,
@@ -48,10 +56,8 @@ struct RAS_LightObject
 	
 	float	m_energy;
 	float	m_distance;
-	
-	float	m_red;
-	float	m_green;
-	float	m_blue;
+
+	float	m_color[3];
 
 	float	m_att1;
 	float	m_att2;
@@ -62,6 +68,17 @@ struct RAS_LightObject
 	
 	bool	m_nodiffuse;
 	bool	m_nospecular;
+	bool	m_glsl;
+
+	virtual ~RAS_ILightObject() {}
+	virtual RAS_ILightObject* Clone() = 0;
+
+	virtual bool HasShadowBuffer() = 0;
+	virtual int GetShadowLayer() = 0;
+	virtual void BindShadowBuffer(RAS_ICanvas *canvas, KX_Camera *cam, MT_Transform& camtrans) = 0;
+	virtual void UnbindShadowBuffer() = 0;
+	virtual Image *GetTextureImage(short texslot) = 0;
+	virtual void Update() = 0;
 };
 
 #endif  /* __RAS_LIGHTOBJECT_H__ */
diff --git a/source/gameengine/Rasterizer/RAS_IRasterizer.h b/source/gameengine/Rasterizer/RAS_IRasterizer.h
index 887ebc476b0..d7b52213191 100644
--- a/source/gameengine/Rasterizer/RAS_IRasterizer.h
+++ b/source/gameengine/Rasterizer/RAS_IRasterizer.h
@@ -53,6 +53,7 @@ using namespace std;
 class RAS_ICanvas;
 class RAS_IPolyMaterial;
 class RAS_MeshSlot;
+class RAS_ILightObject;
 
 typedef vector<unsigned short> KX_IndexArray;
 typedef vector<RAS_TexVert> KX_VertexArray;
@@ -470,9 +471,11 @@ public:
 
 	virtual void PopMatrix() = 0;
 
-	virtual void AddLight(struct RAS_LightObject *lightobject) = 0;
+	virtual RAS_ILightObject *CreateLight() = 0;
 
-	virtual void RemoveLight(struct RAS_LightObject *lightobject) = 0;
+	virtual void AddLight(RAS_ILightObject *lightobject) = 0;
+
+	virtual void RemoveLight(RAS_ILightObject *lightobject) = 0;
 
 	virtual void MotionBlur() = 0;
 
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
index 76ac6316e38..f0410ba891d 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
@@ -50,6 +50,7 @@ set(INC_SYS
 set(SRC
 	RAS_GLExtensionManager.cpp
 	RAS_ListRasterizer.cpp
+	RAS_OpenGLLight.cpp
 	RAS_OpenGLRasterizer.cpp
 	RAS_StorageIM.cpp
 	RAS_StorageVA.cpp
@@ -58,6 +59,7 @@ set(SRC
 	RAS_GLExtensionManager.h
 	RAS_IStorage.h
 	RAS_ListRasterizer.h
+	RAS_OpenGLLight.h
 	RAS_OpenGLRasterizer.h
 	RAS_StorageIM.h
 	RAS_StorageVA.h
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLLight.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLLight.cpp
new file mode 100644
index 00000000000..91ad2838ccd
--- /dev/null
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLLight.cpp
@@ -0,0 +1,276 @@
+/*
+ * ***** BEGIN GPL 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.
+ *
+ * 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Mitchell Stokes
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "GL/glew.h"
+
+#include "RAS_OpenGLLight.h"
+#include "RAS_OpenGLRasterizer.h"
+#include "RAS_ICanvas.h"
+
+#include "MT_CmMatrix4x4.h"
+
+#include "KX_Camera.h"
+#include "KX_Light.h"
+#include "KX_Scene.h"
+
+#include "DNA_lamp_types.h"
+#include "DNA_scene_types.h"
+
+#include "GPU_material.h"
+
+RAS_OpenGLLight::RAS_OpenGLLight(RAS_OpenGLRasterizer *ras)
+    :m_rasterizer(ras)
+{
+}
+
+RAS_OpenGLLight::~RAS_OpenGLLight()
+{
+	GPULamp *lamp;
+	KX_LightObject* kxlight = (KX_LightObject*)m_light;
+	Lamp *la = (Lamp*)kxlight->GetBlenderObject()->data;
+
+	if ((lamp = GetGPULamp())) {
+		float obmat[4][4] = {{0}};
+		GPU_lamp_update(lamp, 0, 0, obmat);
+		GPU_lamp_update_distance(lamp, la->dist, la->att1, la->att2);
+		GPU_lamp_update_spot(lamp, la->spotsize, la->spotblend);
+	}
+}
+
+bool RAS_OpenGLLight::ApplyFixedFunctionLighting(KX_Scene *kxscene, int oblayer, int slot)
+{
+	KX_Scene* lightscene = (KX_Scene*)m_scene;
+	KX_LightObject* kxlight = (KX_LightObject*)m_light;
+	float vec[4];
+	int scenelayer = ~0;
+
+	if (kxscene && kxscene->GetBlenderScene())
+		scenelayer = kxscene->GetBlenderScene()->lay;
+
+	/* only use lights in the same layer as the object */
+	if (!(m_layer & oblayer))
+		return false;
+	/* only use lights in the same scene, and in a visible layer */
+	if (kxscene != lightscene || !(m_layer & scenelayer))
+		return false;
+
+	// lights don't get their openGL matrix updated, do it now
+	if (kxlight->GetSGNode()->IsDirty())
+		kxlight->GetOpenGLMatrix();
+
+	MT_CmMatrix4x4& worldmatrix= *kxlight->GetOpenGLMatrixPtr();
+
+	vec[0] = worldmatrix(0,3);
+	vec[1] = worldmatrix(1,3);
+	vec[2] = worldmatrix(2,3);
+	vec[3] = 1.0f;
+
+	if (m_type==RAS_ILightObject::LIGHT_SUN) {
+
+		vec[0] = worldmatrix(0,2);
+		vec[1] = worldmatrix(1,2);
+		vec[2] = worldmatrix(2,2);
+		//vec[0] = base->object->obmat[2][0];
+		//vec[1] = base->object->obmat[2][1];
+		//vec[2] = base->object->obmat[2][2];
+		vec[3] = 0.0;
+		glLightfv((GLenum)(GL_LIGHT0+slot), GL_POSITION, vec);
+	}
+	else {
+		//vec[3] = 1.0;
+		glLightfv((GLenum)(GL_LIGHT0+slot), GL_POSITION, vec);
+		glLightf((GLenum)(GL_LIGHT0+slot), GL_CONSTANT_ATTENUATION, 1.0);
+		glLightf((GLenum)(GL_LIGHT0+slot), GL_LINEAR_ATTENUATION, m_att1/m_distance);
+		// without this next line it looks backward compatible.
+		//attennuation still is acceptable
+		glLightf((GLenum)(GL_LIGHT0+slot), GL_QUADRATIC_ATTENUATION, m_att2/(m_distance*m_distance));
+
+		if (m_type==RAS_ILightObject::LIGHT_SPOT) {
+			vec[0] = -worldmatrix(0,2);
+			vec[1] = -worldmatrix(1,2);
+			vec[2] = -worldmatrix(2,2);
+			//vec[0] = -base->object->obmat[2][0];
+			//vec[1] = -base->object->obmat[2][1];
+			//vec[2] = -base->object->obmat[2][2];
+			glLightfv((GLenum)(GL_LIGHT0+slot), GL_SPOT_DIRECTION, vec);
+			glLightf((GLenum)(GL_LIGHT0+slot), GL_SPOT_CUTOFF, m_spotsize / 2.0f);
+			glLightf((GLenum)(GL_LIGHT0+slot), GL_SPOT_EXPONENT, 128.0f * m_spotblend);
+		}
+		else {
+			glLightf((GLenum)(GL_LIGHT0+slot), GL_SPOT_CUTOFF, 180.0);
+		}
+	}
+
+	if (m_nodiffuse) {
+		vec[0] = vec[1] = vec[2] = vec[3] = 0.0;
+	}
+	else {
+		vec[0] = m_energy*m_color[0];
+		vec[1] = m_energy*m_color[1];
+		vec[2] = m_energy*m_color[2];
+		vec[3] = 1.0;
+	}
+
+	glLightfv((GLenum)(GL_LIGHT0+slot), GL_DIFFUSE, vec);
+	if (m_nospecular)
+	{
+		vec[0] = vec[1] = vec[2] = vec[3] = 0.0;
+	}
+	else if (m_nodiffuse) {
+		vec[0] = m_energy*m_color[0];
+		vec[1] = m_energy*m_color[1];
+		vec[2] = m_energy*m_color[2];
+		vec[3] = 1.0;
+	}
+
+	glLightfv((GLenum)(GL_LIGHT0+slot), GL_SPECULAR, vec);
+	glEnable((GLenum)(GL_LIGHT0+slot));
+
+	return true;
+}
+
+GPULamp *RAS_OpenGLLight::GetGPULamp()
+{
+	KX_LightObject* kxlight = (KX_LightObject*)m_light;
+
+	if (m_glsl)
+		return GPU_lamp_from_blender(kxlight->GetScene()->GetBlenderScene(), kxlight->GetBlenderObject(), kxlight->GetBlenderGroupObject());
+	else
+		return NULL;
+}
+
+
+bool RAS_OpenGLLight::HasShadowBuffer()
+{
+	GPULamp *lamp;
+
+	if ((lamp = GetGPULamp()))
+		return GPU_lamp_has_shadow_buffer(lamp);
+	else
+		return false;
+}
+
+int RAS_OpenGLLight::GetShadowLayer()
+{
+	GPULamp *lamp;
+
+	if ((lamp = GetGPULamp()))
+		return GPU_lamp_shadow_layer(lamp);
+	else
+		return 0;
+}
+
+void RAS_OpenGLLight::BindShadowBuffer(RAS_ICanvas *canvas, KX_Camera *cam, MT_Transform& camtrans)
+{
+	GPULamp *lamp;
+	float viewmat[4][4], winmat[4][4];
+	int winsize;
+
+	/* bind framebuffer */
+	lamp = GetGPULamp();
+	GPU_lamp_shadow_buffer_bind(lamp, viewmat, &winsize, winmat);
+
+	if (GPU_lamp_shadow_buffer_type(lamp) == LA_SHADMAP_VARIANCE)
+		m_rasterizer->SetUsingOverrideShader(true);
+
+	/* GPU_lamp_shadow_buffer_bind() changes the viewport, so update the canvas */
+	canvas->UpdateViewPort(0, 0, winsize, winsize);
+
+	/* setup camera transformation */
+	MT_Matrix4x4 modelviewmat((float*)viewmat);
+	MT_Matrix4x4 projectionmat((float*)winmat);
+
+	MT_Transform trans = MT_Transform((float*)viewmat);
+	camtrans.invert(trans);
+
+	cam->SetModelviewMatrix(modelviewmat);
+	cam->SetProjectionMatrix(projectionmat);
+
+	cam->NodeSetLocalPosition(camtrans.getOrigin());
+	cam->NodeSetLocalOrientation(camtrans.getBasis());
+	cam->NodeUpdateGS(0);
+
+	/* setup rasterizer transformations */
+	/* SetViewMatrix may use stereomode which we temporarily disable here */
+	RAS_IRasterizer::StereoMode stereomode = m_rasterizer->GetStereoMode();
+	m_rasterizer->SetStereoMode(RAS_IRasterizer::RAS_STEREO_NOSTEREO);
+	m_rasterizer->SetProjectionMatrix(projectionmat);
+	m_rasterizer->SetViewMatrix(modelviewmat, cam->NodeGetWorldOrientation(), cam->NodeGetWorldPosition(), cam->GetCameraData()->m_perspective);
+	m_rasterizer->SetStereoMode(stereomode);
+}
+
+void RAS_OpenGLLight::UnbindShadowBuffer()
+{
+	GPULamp *lamp = GetGPULamp();
+	GPU_lamp_shadow_buffer_unbind(lamp);
+
+	if (GPU_lamp_shadow_buffer_type(lamp) == LA_SHADMAP_VARIANCE)
+		m_rasterizer->SetUsingOverrideShader(false);
+}
+
+Image *RAS_OpenGLLight::GetTextureImage(short texslot)
+{
+	KX_LightObject* kxlight = (KX_LightObject*)m_light;
+	Lamp *la = (Lamp*)kxlight->GetBlenderObject()->data;
+
+	if (texslot >= MAX_MTEX || texslot < 0)
+	{
+		printf("KX_LightObject::GetTextureImage(): texslot exceeds slot bounds (0-%d)\n", MAX_MTEX-1);
+		return NULL;
+	}
+
+	if (la->mtex[texslot])
+		return la->mtex[texslot]->tex->ima;
+
+	return NULL;
+}
+
+void RAS_OpenGLLight::Update()
+{
+	GPULamp *lamp;
+	KX_LightObject* kxlight = (KX_LightObject*)m_light;
+
+	if ((lamp = GetGPULamp()) != NULL && kxlight->GetSGNode()) {
+		float obmat[4][4];
+		// lights don't get their openGL matrix updated, do it now
+		if (kxlight->GetSGNode()->IsDirty())
+			kxlight->GetOpenGLMatrix();
+		double *dobmat = kxlight->GetOpenGLMatrixPtr()->getPointer();
+
+		for (int i=0; i<4; i++)
+			for (int j=0; j<4; j++, dobmat++)
+				obmat[i][j] = (float)*dobmat;
+
+		GPU_lamp_update(lamp, m_layer, 0, obmat);
+		GPU_lamp_update_colors(lamp, m_color[0], m_color[1],
+			m_color[2], m_energy);
+		GPU_lamp_update_distance(lamp, m_distance, m_att1, m_att2);
+		GPU_lamp_update_spot(lamp, m_spotsize, m_spotblend);
+	}
+}
+
+
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLLight.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLLight.h
new file mode 100644
index 00000000000..0c4e5bf41c4
--- /dev/null
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLLight.h
@@ -0,0 +1,54 @@
+/*
+ * ***** BEGIN GPL 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.
+ *
+ * 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Mitchell Stokes
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "RAS_ILightObject.h"
+
+class RAS_OpenGLRasterizer;
+struct GPULamp;
+struct Image;
+
+class RAS_OpenGLLight : public RAS_ILightObject
+{
+
+	RAS_OpenGLRasterizer *m_rasterizer;
+
+	GPULamp *GetGPULamp();
+public:
+	RAS_OpenGLLight(RAS_OpenGLRasterizer *ras);
+	~RAS_OpenGLLight();
+
+	bool ApplyFixedFunctionLighting(KX_Scene *kxscene, int oblayer, int slot);
+
+	RAS_OpenGLLight* Clone() { return new RAS_OpenGLLight(*this); }
+
+	bool HasShadowBuffer();
+	int GetShadowLayer();
+	void BindShadowBuffer(RAS_ICanvas *canvas, KX_Camera *cam, MT_Transform& camtrans);
+	void UnbindShadowBuffer();
+	Image *GetTextureImage(short texslot);
+	void Update();
+};
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
index 63355696082..1227fe892a3 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
@@ -42,9 +42,11 @@
 #include "RAS_TexVert.h"
 #include "RAS_MeshObject.h"
 #include "RAS_Polygon.h"
-#include "RAS_LightObject.h"
+#include "RAS_ILightObject.h"
 #include "MT_CmMatrix4x4.h"
 
+#include "RAS_OpenGLLight.h"
+
 #include "RAS_StorageIM.h"
 #include "RAS_StorageVA.h"
 #include "RAS_StorageVBO.h"
@@ -59,7 +61,6 @@ extern "C"{
 
 // XXX Clean these up <<<
 #include "Value.h"
-#include "KX_Light.h"
 #include "KX_Scene.h"
 #include "KX_RayCast.h"
 #include "KX_GameObject.h"
@@ -1187,7 +1188,7 @@ void RAS_OpenGLRasterizer::ProcessLighting(bool uselights, const MT_Transform& v
 		KX_Scene* kxscene = (KX_Scene*)m_auxilaryClientInfo;
 		float glviewmat[16];
 		unsigned int count;
-		std::vector<struct	RAS_LightObject*>::iterator lit = m_lights.begin();
+		std::vector<RAS_OpenGLLight*>::iterator lit = m_lights.begin();
 
 		for (count=0; count<m_numgllights; count++)
 			glDisable((GLenum)(GL_LIGHT0+count));
@@ -1198,10 +1199,9 @@ void RAS_OpenGLRasterizer::ProcessLighting(bool uselights, const MT_Transform& v
 		glLoadMatrixf(glviewmat);
 		for (lit = m_lights.begin(), count = 0; !(lit==m_lights.end()) && count < m_numgllights; ++lit)
 		{
-			RAS_LightObject* lightdata = (*lit);
-			KX_LightObject *kxlight = (KX_LightObject*)lightdata->m_light;
+			RAS_OpenGLLight* light = (*lit);
 
-			if (kxlight->ApplyLight(kxscene, layer, count))
+			if (light->ApplyFixedFunctionLighting(kxscene, layer, count))
 				count++;
 		}
 		glPopMatrix();
@@ -1243,15 +1243,25 @@ void RAS_OpenGLRasterizer::DisableOpenGLLights()
 	m_lastlighting = false;
 }
 
-void RAS_OpenGLRasterizer::AddLight(struct RAS_LightObject* lightobject)
+RAS_ILightObject *RAS_OpenGLRasterizer::CreateLight()
 {
-	m_lights.push_back(lightobject);
+	return new RAS_OpenGLLight(this);
 }
 
-void RAS_OpenGLRasterizer::RemoveLight(struct RAS_LightObject* lightobject)
+void RAS_OpenGLRasterizer::AddLight(RAS_ILightObject* lightobject)
 {
-	std::vector<struct	RAS_LightObject*>::iterator lit =
-		std::find(m_lights.begin(),m_lights.end(),lightobject);
+	RAS_OpenGLLight* gllight = dynamic_cast<RAS_OpenGLLight*>(lightobject);
+	assert(gllight);
+	m_lights.push_back(gllight);
+}
+
+void RAS_OpenGLRasterizer::RemoveLight(RAS_ILightObject* lightobject)
+{
+	RAS_OpenGLLight* gllight = dynamic_cast<RAS_OpenGLLight*>(lightobject);
+	assert(gllight);
+
+	std::vector<RAS_OpenGLLight*>::iterator lit =
+		std::find(m_lights.begin(),m_lights.end(),gllight);
 
 	if (!(lit==m_lights.end()))
 		m_lights.erase(lit);
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
index ae9e89cd8cc..1334ddb2a26 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
@@ -46,6 +46,7 @@ using namespace std;
 
 class RAS_IStorage;
 class RAS_ICanvas;
+class RAS_OpenGLLight;
 
 #define RAS_MAX_TEXCO  8     /* match in BL_Material */
 #define RAS_MAX_ATTRIB 16    /* match in BL_BlenderShader */
@@ -117,7 +118,7 @@ class RAS_OpenGLRasterizer : public RAS_IRasterizer
 	/* Render tools */
 	void *m_clientobject;
 	void *m_auxilaryClientInfo;
-	std::vector<struct RAS_LightObject *> m_lights;
+	std::vector<RAS_OpenGLLight *> m_lights;
 	int m_lastlightlayer;
 	bool m_lastlighting;
 	void *m_lastauxinfo;
@@ -315,9 +316,11 @@ public:
 	bool RayHit(struct KX_ClientObjectInfo *client, class KX_RayCast *result, void * const data);
 	bool NeedRayCast(struct KX_ClientObjectInfo *) { return true; }
 
-	void AddLight(struct RAS_LightObject *lightobject);
-	void RemoveLight(struct RAS_LightObject *lightobject);
-	int ApplyLights(int objectlayer, const MT_Transform &viewmat);
+	RAS_ILightObject* CreateLight();
+	void AddLight(RAS_ILightObject* lightobject);
+
+	void RemoveLight(RAS_ILightObject* lightobject);
+	int ApplyLights(int objectlayer, const MT_Transform& viewmat);
 
 	void MotionBlur();