3 * ***** BEGIN GPL LICENSE BLOCK *****
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software Foundation,
17 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20 * All rights reserved.
22 * The Original Code is: all of this file.
24 * Contributor(s): none yet.
26 * ***** END GPL LICENSE BLOCK *****
35 #pragma warning (disable : 4786)
41 #include "KX_Camera.h"
42 #include "RAS_IRasterizer.h"
43 #include "RAS_IRenderTools.h"
45 #include "KX_PyMath.h"
47 #include "DNA_object_types.h"
48 #include "DNA_scene_types.h"
49 #include "GPU_material.h"
51 KX_LightObject::KX_LightObject(void* sgReplicationInfo,SG_Callbacks callbacks,
52 class RAS_IRenderTools* rendertools,
53 const RAS_LightObject& lightobj,
58 KX_GameObject(sgReplicationInfo,callbacks,T),
59 m_rendertools(rendertools)
61 m_lightobj = lightobj;
62 m_lightobj.m_scene = sgReplicationInfo;
63 m_lightobj.m_light = this;
64 m_rendertools->AddLight(&m_lightobj);
66 m_blenderscene = ((KX_Scene*)sgReplicationInfo)->GetBlenderScene();
70 KX_LightObject::~KX_LightObject()
74 if((lamp = GetGPULamp())) {
75 float obmat[4][4] = {{0}};
76 GPU_lamp_update(lamp, 0, obmat);
79 m_rendertools->RemoveLight(&m_lightobj);
83 CValue* KX_LightObject::GetReplica()
86 KX_LightObject* replica = new KX_LightObject(*this);
88 replica->ProcessReplica();
90 replica->m_lightobj.m_light = replica;
91 m_rendertools->AddLight(&replica->m_lightobj);
96 bool KX_LightObject::ApplyLight(KX_Scene *kxscene, int oblayer, int slot)
98 KX_Scene* lightscene = (KX_Scene*)m_lightobj.m_scene;
102 if(kxscene && kxscene->GetBlenderScene())
103 scenelayer = kxscene->GetBlenderScene()->lay;
105 /* only use lights in the same layer as the object */
106 if(!(m_lightobj.m_layer & oblayer))
108 /* only use lights in the same scene, and in a visible layer */
109 if(kxscene != lightscene || !(m_lightobj.m_layer & scenelayer))
112 // lights don't get their openGL matrix updated, do it now
113 if(GetSGNode()->IsDirty())
116 MT_CmMatrix4x4& worldmatrix= *GetOpenGLMatrixPtr();
118 vec[0] = worldmatrix(0,3);
119 vec[1] = worldmatrix(1,3);
120 vec[2] = worldmatrix(2,3);
123 if(m_lightobj.m_type==RAS_LightObject::LIGHT_SUN) {
125 vec[0] = worldmatrix(0,2);
126 vec[1] = worldmatrix(1,2);
127 vec[2] = worldmatrix(2,2);
128 //vec[0]= base->object->obmat[2][0];
129 //vec[1]= base->object->obmat[2][1];
130 //vec[2]= base->object->obmat[2][2];
132 glLightfv((GLenum)(GL_LIGHT0+slot), GL_POSITION, vec);
136 glLightfv((GLenum)(GL_LIGHT0+slot), GL_POSITION, vec);
137 glLightf((GLenum)(GL_LIGHT0+slot), GL_CONSTANT_ATTENUATION, 1.0);
138 glLightf((GLenum)(GL_LIGHT0+slot), GL_LINEAR_ATTENUATION, m_lightobj.m_att1/m_lightobj.m_distance);
139 // without this next line it looks backward compatible.
140 //attennuation still is acceptable
141 glLightf((GLenum)(GL_LIGHT0+slot), GL_QUADRATIC_ATTENUATION, m_lightobj.m_att2/(m_lightobj.m_distance*m_lightobj.m_distance));
143 if(m_lightobj.m_type==RAS_LightObject::LIGHT_SPOT) {
144 vec[0] = -worldmatrix(0,2);
145 vec[1] = -worldmatrix(1,2);
146 vec[2] = -worldmatrix(2,2);
147 //vec[0]= -base->object->obmat[2][0];
148 //vec[1]= -base->object->obmat[2][1];
149 //vec[2]= -base->object->obmat[2][2];
150 glLightfv((GLenum)(GL_LIGHT0+slot), GL_SPOT_DIRECTION, vec);
151 glLightf((GLenum)(GL_LIGHT0+slot), GL_SPOT_CUTOFF, m_lightobj.m_spotsize/2.0);
152 glLightf((GLenum)(GL_LIGHT0+slot), GL_SPOT_EXPONENT, 128.0*m_lightobj.m_spotblend);
155 glLightf((GLenum)(GL_LIGHT0+slot), GL_SPOT_CUTOFF, 180.0);
158 if (m_lightobj.m_nodiffuse) {
159 vec[0] = vec[1] = vec[2] = vec[3] = 0.0;
162 vec[0]= m_lightobj.m_energy*m_lightobj.m_red;
163 vec[1]= m_lightobj.m_energy*m_lightobj.m_green;
164 vec[2]= m_lightobj.m_energy*m_lightobj.m_blue;
168 glLightfv((GLenum)(GL_LIGHT0+slot), GL_DIFFUSE, vec);
169 if(m_lightobj.m_nospecular)
171 vec[0] = vec[1] = vec[2] = vec[3] = 0.0;
173 else if (m_lightobj.m_nodiffuse) {
174 vec[0]= m_lightobj.m_energy*m_lightobj.m_red;
175 vec[1]= m_lightobj.m_energy*m_lightobj.m_green;
176 vec[2]= m_lightobj.m_energy*m_lightobj.m_blue;
180 glLightfv((GLenum)(GL_LIGHT0+slot), GL_SPECULAR, vec);
181 glEnable((GLenum)(GL_LIGHT0+slot));
186 GPULamp *KX_LightObject::GetGPULamp()
189 return GPU_lamp_from_blender(m_blenderscene, GetBlenderObject(), GetBlenderGroupObject());
194 void KX_LightObject::Update()
198 if((lamp = GetGPULamp()) != NULL && GetSGNode()) {
200 // lights don't get their openGL matrix updated, do it now
201 if (GetSGNode()->IsDirty())
203 double *dobmat = GetOpenGLMatrixPtr()->getPointer();
205 for(int i=0; i<4; i++)
206 for(int j=0; j<4; j++, dobmat++)
207 obmat[i][j] = (float)*dobmat;
209 GPU_lamp_update(lamp, m_lightobj.m_layer, obmat);
210 GPU_lamp_update_colors(lamp, m_lightobj.m_red, m_lightobj.m_green,
211 m_lightobj.m_blue, m_lightobj.m_energy);
215 bool KX_LightObject::HasShadowBuffer()
219 if((lamp = GetGPULamp()))
220 return GPU_lamp_has_shadow_buffer(lamp);
225 int KX_LightObject::GetShadowLayer()
229 if((lamp = GetGPULamp()))
230 return GPU_lamp_shadow_layer(lamp);
235 void KX_LightObject::BindShadowBuffer(RAS_IRasterizer *ras, KX_Camera *cam, MT_Transform& camtrans)
238 float viewmat[4][4], winmat[4][4];
241 /* bind framebuffer */
243 GPU_lamp_shadow_buffer_bind(lamp, viewmat, &winsize, winmat);
245 /* setup camera transformation */
246 MT_Matrix4x4 modelviewmat((float*)viewmat);
247 MT_Matrix4x4 projectionmat((float*)winmat);
249 MT_Transform trans = MT_Transform((float*)viewmat);
250 camtrans.invert(trans);
252 cam->SetModelviewMatrix(modelviewmat);
253 cam->SetProjectionMatrix(projectionmat);
255 cam->NodeSetLocalPosition(camtrans.getOrigin());
256 cam->NodeSetLocalOrientation(camtrans.getBasis());
257 cam->NodeUpdateGS(0);
259 /* setup rasterizer transformations */
260 ras->SetProjectionMatrix(projectionmat);
261 ras->SetViewMatrix(modelviewmat, cam->NodeGetWorldOrientation(), cam->NodeGetWorldPosition(), cam->GetCameraData()->m_perspective);
264 void KX_LightObject::UnbindShadowBuffer(RAS_IRasterizer *ras)
266 GPULamp *lamp = GetGPULamp();
267 GPU_lamp_shadow_buffer_unbind(lamp);
270 /* ------------------------------------------------------------------------- */
271 /* Python Integration Hooks */
272 /* ------------------------------------------------------------------------- */
274 PyObject* KX_LightObject::py_getattro_dict() {
275 py_getattro_dict_up(KX_GameObject);
279 PyTypeObject KX_LightObject::Type = {
280 #if (PY_VERSION_HEX >= 0x02060000)
281 PyVarObject_HEAD_INIT(NULL, 0)
283 /* python 2.5 and below */
284 PyObject_HEAD_INIT( NULL ) /* required py macro */
288 sizeof(PyObjectPlus_Proxy),
297 &KX_GameObject::Mapping,
305 PyParentObject KX_LightObject::Parents[] = {
306 &KX_LightObject::Type,
307 &KX_GameObject::Type,
313 PyMethodDef KX_LightObject::Methods[] = {
314 {NULL,NULL} //Sentinel
317 PyAttributeDef KX_LightObject::Attributes[] = {
318 KX_PYATTRIBUTE_INT_RW("layer", 1, 20, true, KX_LightObject, m_lightobj.m_layer),
319 KX_PYATTRIBUTE_FLOAT_RW("energy", 0, 10, KX_LightObject, m_lightobj.m_energy),
320 KX_PYATTRIBUTE_FLOAT_RW("distance", 0.01, 5000, KX_LightObject, m_lightobj.m_distance),
321 KX_PYATTRIBUTE_RW_FUNCTION("color", KX_LightObject, pyattr_get_color, pyattr_set_color),
322 KX_PYATTRIBUTE_RW_FUNCTION("colour", KX_LightObject, pyattr_get_color, pyattr_set_color),
323 KX_PYATTRIBUTE_FLOAT_RW("lin_attenuation", 0, 1, KX_LightObject, m_lightobj.m_att1),
324 KX_PYATTRIBUTE_FLOAT_RW("quad_attenuation", 0, 1, KX_LightObject, m_lightobj.m_att2),
325 KX_PYATTRIBUTE_FLOAT_RW("spotsize", 1, 180, KX_LightObject, m_lightobj.m_spotsize),
326 KX_PYATTRIBUTE_FLOAT_RW("spotblend", 0, 1, KX_LightObject, m_lightobj.m_spotblend),
327 KX_PYATTRIBUTE_RO_FUNCTION("SPOT", KX_LightObject, pyattr_get_typeconst),
328 KX_PYATTRIBUTE_RO_FUNCTION("SUN", KX_LightObject, pyattr_get_typeconst),
329 KX_PYATTRIBUTE_RO_FUNCTION("NORMAL", KX_LightObject, pyattr_get_typeconst),
330 KX_PYATTRIBUTE_RW_FUNCTION("type", KX_LightObject, pyattr_get_type, pyattr_set_type),
334 PyObject* KX_LightObject::pyattr_get_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
336 KX_LightObject* self = static_cast<KX_LightObject*>(self_v);
337 return Py_BuildValue("[fff]", self->m_lightobj.m_red, self->m_lightobj.m_green, self->m_lightobj.m_blue);
340 int KX_LightObject::pyattr_set_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
342 KX_LightObject* self = static_cast<KX_LightObject*>(self_v);
345 if (PyVecTo(value, color))
347 self->m_lightobj.m_red = color[0];
348 self->m_lightobj.m_green = color[1];
349 self->m_lightobj.m_blue = color[2];
350 return PY_SET_ATTR_SUCCESS;
352 return PY_SET_ATTR_FAIL;
355 PyObject* KX_LightObject::pyattr_get_typeconst(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
359 const char* type = attrdef->m_name;
361 if(strcmp(type, "SPOT")) {
362 retvalue = PyInt_FromLong(RAS_LightObject::LIGHT_SPOT);
363 } else if (strcmp(type, "SUN")) {
364 retvalue = PyInt_FromLong(RAS_LightObject::LIGHT_SUN);
365 } else if (strcmp(type, "NORMAL")) {
366 retvalue = PyInt_FromLong(RAS_LightObject::LIGHT_NORMAL);
372 PyObject* KX_LightObject::pyattr_get_type(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef)
374 KX_LightObject* self = static_cast<KX_LightObject*>(self_v);
375 return PyInt_FromLong(self->m_lightobj.m_type);
378 int KX_LightObject::pyattr_set_type(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject* value)
380 KX_LightObject* self = static_cast<KX_LightObject*>(self_v);
381 int val = PyInt_AsLong(value);
382 if((val==-1 && PyErr_Occurred()) || val<0 || val>2) {
383 PyErr_SetString(PyExc_ValueError, "light.type= val: KX_LightObject, expected an int between 0 and 2");
384 return PY_SET_ATTR_FAIL;
389 self->m_lightobj.m_type = self->m_lightobj.LIGHT_SPOT;
392 self->m_lightobj.m_type = self->m_lightobj.LIGHT_SUN;
395 self->m_lightobj.m_type = self->m_lightobj.LIGHT_NORMAL;
399 return PY_SET_ATTR_SUCCESS;
403 PyObject* KX_LightObject::py_getattro(PyObject *attr)
405 py_getattro_up(KX_GameObject);
408 int KX_LightObject::py_setattro(PyObject *attr, PyObject *value)
410 py_setattro_up(KX_GameObject);