diff options
author | Mitchell Stokes <mogurijin@gmail.com> | 2014-03-28 09:32:06 +0400 |
---|---|---|
committer | Mitchell Stokes <mogurijin@gmail.com> | 2014-03-28 09:32:06 +0400 |
commit | df9d6737b912b71fb91579b43ea6c7786d88f803 (patch) | |
tree | 0466230d0ce29d297888826f623426728243a995 /source/gameengine/Rasterizer/RAS_OpenGLRasterizer | |
parent | 3ec0c73211d6786664a303a7413cae4e67ef6cf5 (diff) |
BGE code cleanup: Removing OpenGL and bf_gpu code from KX_LightObject
The ultimate goal is to only allow the rasterizer to handle OpenGL and bf_gpu
calls. This commit creates a RAS_ILightObject interface and a RAS_OpenGLLight
implementation.
Diffstat (limited to 'source/gameengine/Rasterizer/RAS_OpenGLRasterizer')
5 files changed, 360 insertions, 15 deletions
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(); |