BGE: Multitexture world (mist, ambient) fix
authorThomas Szepe <HG1_public@gmx.net>
Mon, 23 Mar 2015 20:36:08 +0000 (21:36 +0100)
committerThomas Szepe <HG1_public@gmx.net>
Mon, 23 Mar 2015 20:36:08 +0000 (21:36 +0100)
This patch fix the existing word API for mist and global ambient lighting.
Add deprecated message to disableMist()
Add setUseMist(enable).

Reviewers: dfelinto, campbellbarton, moguri

Reviewed By: moguri

Subscribers: solarlune, jta, brecht

Projects: #bf_blender:_next

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

doc/python_api/rst/bge.render.rst
source/gameengine/Converter/BlenderWorldInfo.cpp
source/gameengine/Converter/BlenderWorldInfo.h
source/gameengine/Ketsji/KX_KetsjiEngine.cpp
source/gameengine/Ketsji/KX_PythonInit.cpp
source/gameengine/Ketsji/KX_WorldInfo.h
source/gameengine/Ketsji/KX_WorldIpoController.cpp
source/gameengine/Rasterizer/RAS_IRasterizer.h
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h

index 77d5bd717610308c7f04acf4d1354e9c75730d21..3abbd50a4535b2143df23ac5b72d0412a363fbd8 100644 (file)
@@ -198,9 +198,16 @@ Functions
 
    Disables mist.
    
-   .. note:: Set any of the mist properties to enable mist.
+   .. note:: Deprecated use setUseMist().
 
    
+.. function:: setUseMist(enable)
+
+   Disable or enable the mist.
+
+   :type enable: boolean
+
+
 .. function:: setEyeSeparation(eyesep)
 
    Sets the eye separation for stereo mode. Usually Focal Length/30 provides a confortable value.
index 75beb5d0e0e7ac1325d3f90d7f8ed2e81b2d887b..28e42c1cc63849230ef436c0d207233fe6a4a1ec 100644 (file)
@@ -69,21 +69,10 @@ BlenderWorldInfo::BlenderWorldInfo(struct Scene *blenderscene, struct World *ble
 {
        if (blenderworld) {
                m_hasworld = true;
-
-               // do we have mist?
-               if ((blenderworld->mode) & WO_MIST) {
-                       m_hasmist = true;
-                       m_miststart = blenderworld->miststa;
-                       m_mistdistance = blenderworld->mistdist;
-                       copy_v3_v3(m_mistcolor, &blenderworld->horr);
-               }
-               else {
-                       m_hasmist = false;
-                       m_miststart = 0.0;
-                       m_mistdistance = 0.0;
-                       zero_v3(m_mistcolor);
-               }
-
+               m_hasmist = ((blenderworld->mode) & WO_MIST ? true : false);
+               m_miststart = blenderworld->miststa;
+               m_mistdistance = blenderworld->mistdist;
+               copy_v3_v3(m_mistcolor, &blenderworld->horr);
                copy_v3_v3(m_backgroundcolor, &blenderworld->horr);
                copy_v3_v3(m_ambientcolor, &blenderworld->ambr);
 
@@ -174,6 +163,11 @@ void BlenderWorldInfo::setBackColor(float r, float g, float b)
        m_backgroundcolor[2] = b;
 }
 
+void BlenderWorldInfo::setUseMist(bool enable)
+{
+       m_hasmist = enable;
+}
+
 void BlenderWorldInfo::setMistStart(float d)
 {
        m_miststart = d;
@@ -184,17 +178,16 @@ void BlenderWorldInfo::setMistDistance(float d)
        m_mistdistance = d;
 }
 
-void BlenderWorldInfo::setMistColorRed(float d)
-{
-       m_mistcolor[0] = d;
-}
-
-void BlenderWorldInfo::setMistColorGreen(float d)
+void BlenderWorldInfo::setMistColor(float r, float g, float b)
 {
-       m_mistcolor[1] = d;
+       m_mistcolor[0] = r;
+       m_mistcolor[1] = g;
+       m_mistcolor[2] = b;
 }
 
-void BlenderWorldInfo::setMistColorBlue(float d)
+void BlenderWorldInfo::setAmbientColor(float r, float g, float b)
 {
-       m_mistcolor[2] = d;
+       m_ambientcolor[0] = r;
+       m_ambientcolor[1] = g;
+       m_ambientcolor[2] = b;
 }
index 2ac2d70b5d1157d34bb4d414b52ee11fee3b9ee5..6c67681c3bc0401ab3cfdad6c5aca07c1c802a3a 100644 (file)
@@ -67,11 +67,11 @@ public:
        float getMistColorBlue();
 
        void setBackColor(float r, float g, float b);
+       void setUseMist(bool enable);
        void setMistStart(float d);
        void setMistDistance(float d);
-       void setMistColorRed(float d);
-       void setMistColorGreen(float d);
-       void setMistColorBlue(float d);
+       void setMistColor(float r, float g, float b);
+       void setAmbientColor(float r, float g, float b);
 
 
 #ifdef WITH_CXX_GUARDEDALLOC
index e453b757b7efb4951741e94160642c18f313804e..44b667e15e0aadbf4d27798d60be1eaf3eaaba31 100644 (file)
@@ -985,15 +985,14 @@ void KX_KetsjiEngine::SetWorldSettings(KX_WorldInfo* wi)
 {
        if (wi->hasWorld())
        {
-               // ...
-               m_rasterizer->SetAmbientColor(
-                       wi->getAmbientColorRed(),
-                       wi->getAmbientColorGreen(),
-                       wi->getAmbientColorBlue()
-               );
-
                if (m_rasterizer->GetDrawingMode() >= RAS_IRasterizer::KX_SOLID)
                {
+                       m_rasterizer->SetAmbientColor(
+                               wi->getAmbientColorRed(),
+                               wi->getAmbientColorGreen(),
+                               wi->getAmbientColorBlue()
+                               );
+
                        if (wi->hasMist())
                        {
                                m_rasterizer->SetFog(
@@ -1003,6 +1002,10 @@ void KX_KetsjiEngine::SetWorldSettings(KX_WorldInfo* wi)
                                        wi->getMistColorGreen(),
                                        wi->getMistColorBlue()
                                );
+                               m_rasterizer->EnableFog(true);
+                       }
+                       else {
+                               m_rasterizer->EnableFog(false);
                        }
                }
        }
index d7dd3fe5253266232eaa33db881823804c727a3d..e0af3283f447d7700875f932caa2801c286bc7b1 100644 (file)
@@ -1029,108 +1029,118 @@ static PyObject *gPyGetStereoEye(PyObject *, PyObject *, PyObject *)
 
 static PyObject *gPySetBackgroundColor(PyObject *, PyObject *value)
 {
-       
        MT_Vector4 vec;
        if (!PyVecTo(value, vec))
                return NULL;
-       
-       if (gp_Canvas)
-       {
-               gp_Rasterizer->SetBackColor((float)vec[0], (float)vec[1], (float)vec[2], (float)vec[3]);
-       }
 
        KX_WorldInfo *wi = gp_KetsjiScene->GetWorldInfo();
-       if (wi->hasWorld())
-               wi->setBackColor((float)vec[0], (float)vec[1], (float)vec[2]);
+       if (!wi->hasWorld()) {
+               PyErr_SetString(PyExc_RuntimeError, "bge.render.SetBackgroundColor(color), World not available");
+               return NULL;
+       }
+
+       wi->setBackColor((float)vec[0], (float)vec[1], (float)vec[2]);
 
        Py_RETURN_NONE;
 }
 
-
-
 static PyObject *gPySetMistColor(PyObject *, PyObject *value)
 {
-       
        MT_Vector3 vec;
        if (!PyVecTo(value, vec))
                return NULL;
-       
-       if (!gp_Rasterizer) {
-               PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setMistColor(color), Rasterizer not available");
+
+       KX_WorldInfo *wi = gp_KetsjiScene->GetWorldInfo();
+       if (!wi->hasWorld()) {
+               PyErr_SetString(PyExc_RuntimeError, "bge.render.setMistColor(color), World not available");
                return NULL;
        }
-       gp_Rasterizer->SetFogColor((float)vec[0], (float)vec[1], (float)vec[2]);
-       
+
+       wi->setMistColor((float)vec[0], (float)vec[1], (float)vec[2]);
+
        Py_RETURN_NONE;
 }
 
 static PyObject *gPyDisableMist(PyObject *)
 {
-       
-       if (!gp_Rasterizer) {
-               PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setMistColor(color), Rasterizer not available");
+       KX_WorldInfo *wi = gp_KetsjiScene->GetWorldInfo();
+       if (!wi->hasWorld()) {
+               PyErr_SetString(PyExc_RuntimeError, "bge.render.DisableMist(), World not available");
                return NULL;
        }
-       gp_Rasterizer->DisableFog();
-       
+       ShowDeprecationWarning("DisableMist()", "setUseMist(false)");
+       wi->setUseMist(false);
+
        Py_RETURN_NONE;
 }
 
-static PyObject *gPySetMistStart(PyObject *, PyObject *args)
+static PyObject *gPySetUseMist(PyObject *, PyObject *args)
 {
+       int enable;
+       if (!PyArg_ParseTuple(args,"i:setUseMist",&enable))
+               return NULL;
+
+       KX_WorldInfo *wi = gp_KetsjiScene->GetWorldInfo();
+       if (!wi->hasWorld()) {
+               PyErr_SetString(PyExc_RuntimeError, "bge.render.setUseMist(enable), World not available");
+               return NULL;
+       }
+
+       wi->setUseMist(enable);
+
+       Py_RETURN_NONE;
+}
 
+static PyObject *gPySetMistStart(PyObject *, PyObject *args)
+{
        float miststart;
        if (!PyArg_ParseTuple(args,"f:setMistStart",&miststart))
                return NULL;
-       
-       if (!gp_Rasterizer) {
-               PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setMistStart(float), Rasterizer not available");
+
+       KX_WorldInfo *wi = gp_KetsjiScene->GetWorldInfo();
+       if (!wi->hasWorld()) {
+               PyErr_SetString(PyExc_RuntimeError, "bge.render.setMistStart(float), World not available");
                return NULL;
        }
-       
-       gp_Rasterizer->SetFogStart(miststart);
-       
-       Py_RETURN_NONE;
-}
 
+       wi->setMistStart(miststart);
 
+       Py_RETURN_NONE;
+}
 
 static PyObject *gPySetMistEnd(PyObject *, PyObject *args)
 {
-
-       float mistend;
-       if (!PyArg_ParseTuple(args,"f:setMistEnd",&mistend))
+       float mistdist;
+       if (!PyArg_ParseTuple(args,"f:setMistEnd",&mistdist))
                return NULL;
-       
-       if (!gp_Rasterizer) {
-               PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setMistEnd(float), Rasterizer not available");
+
+       KX_WorldInfo *wi = gp_KetsjiScene->GetWorldInfo();
+       if (!wi->hasWorld()) {
+               PyErr_SetString(PyExc_RuntimeError, "bge.render.setMistEnd(float), World not available");
                return NULL;
        }
-       
-       gp_Rasterizer->SetFogEnd(mistend);
-       
+
+       wi->setMistDistance(mistdist);
+
        Py_RETURN_NONE;
 }
 
-
 static PyObject *gPySetAmbientColor(PyObject *, PyObject *value)
 {
-       
        MT_Vector3 vec;
        if (!PyVecTo(value, vec))
                return NULL;
-       
-       if (!gp_Rasterizer) {
-               PyErr_SetString(PyExc_RuntimeError, "Rasterizer.setAmbientColor(color), Rasterizer not available");
+
+       KX_WorldInfo *wi = gp_KetsjiScene->GetWorldInfo();
+       if (!wi->hasWorld()) {
+               PyErr_SetString(PyExc_RuntimeError, "bge.render.setAmbientColor(color), World not available");
                return NULL;
        }
-       gp_Rasterizer->SetAmbientColor((float)vec[0], (float)vec[1], (float)vec[2]);
-       
-       Py_RETURN_NONE;
-}
-
 
+       wi->setAmbientColor((float)vec[0], (float)vec[1], (float)vec[2]);
 
+       Py_RETURN_NONE;
+}
 
 static PyObject *gPyMakeScreenshot(PyObject *, PyObject *args)
 {
@@ -1510,9 +1520,10 @@ static struct PyMethodDef rasterizer_methods[] = {
        {"setBackgroundColor",(PyCFunction)gPySetBackgroundColor,METH_O,"set Background Color (rgb)"},
        {"setAmbientColor",(PyCFunction)gPySetAmbientColor,METH_O,"set Ambient Color (rgb)"},
        {"disableMist",(PyCFunction)gPyDisableMist,METH_NOARGS,"turn off mist"},
+       {"setUseMist",(PyCFunction)gPySetUseMist,METH_VARARGS,"enable or disable mist"},
        {"setMistColor",(PyCFunction)gPySetMistColor,METH_O,"set Mist Color (rgb)"},
-       {"setMistStart",(PyCFunction)gPySetMistStart,METH_VARARGS,"set Mist Start(rgb)"},
-       {"setMistEnd",(PyCFunction)gPySetMistEnd,METH_VARARGS,"set Mist End(rgb)"},
+       {"setMistStart",(PyCFunction)gPySetMistStart,METH_VARARGS,"set Mist Start"},
+       {"setMistEnd",(PyCFunction)gPySetMistEnd,METH_VARARGS,"set Mist End"},
        {"enableMotionBlur",(PyCFunction)gPyEnableMotionBlur,METH_VARARGS,"enable motion blur"},
        {"disableMotionBlur",(PyCFunction)gPyDisableMotionBlur,METH_NOARGS,"disable motion blur"},
 
index 90b16fe12423882854bc668990ce4df459a6c9ca..251ba95f43a287aadb88be3a88aa68d4aacdf83e 100644 (file)
@@ -61,12 +61,12 @@ public:
        virtual float getAmbientColorGreen() = 0;
        virtual float getAmbientColorBlue() = 0;
 
-       virtual void setBackColor(float, float, float) = 0;
+       virtual void setUseMist(bool enable) = 0;
        virtual void setMistStart(float) = 0;
        virtual void setMistDistance(float) = 0;
-       virtual void setMistColorRed(float) = 0;
-       virtual void setMistColorGreen(float) = 0;
-       virtual void setMistColorBlue(float) = 0;
+       virtual void setMistColor(float, float, float) = 0;
+       virtual void setBackColor(float, float, float) = 0;
+       virtual void setAmbientColor(float,float,float) = 0;
 
 
 #ifdef WITH_CXX_GUARDEDALLOC
index 7f83a1556432553d994e5ad8d3533ac10f530808..a30d89284b8125f19a24fb32d25fc1e7d5407e3a 100644 (file)
@@ -57,9 +57,7 @@ bool KX_WorldIpoController::Update(double currentTime)
                }
 
                if (m_modify_mist_color) {
-                       world->setMistColorRed(m_mist_rgb[0]);
-                       world->setMistColorGreen(m_mist_rgb[1]);
-                       world->setMistColorBlue(m_mist_rgb[2]);
+                       world->setMistColor(m_mist_rgb[0], m_mist_rgb[1], m_mist_rgb[2]);
                }
 
                if (m_modify_mist_dist) {
index d7b5221319167910b5c052fe5060b53fb825b3d7..6f5273f035f59bbb02aaf0f037b53a892c49816f 100644 (file)
@@ -302,7 +302,7 @@ public:
        virtual void SetFogStart(float start) = 0;
        virtual void SetFogEnd(float end) = 0;
        virtual void DisplayFog() = 0;
-       virtual void DisableFog() = 0;
+       virtual void EnableFog(bool enable) = 0;
        virtual bool IsFogEnabled() = 0;
 
        virtual void SetBackColor(float red, float green, float blue, float alpha) = 0;
index 116a11339d9ee276cf8e701a7e457a8af9263b31..14a184bbe7f59075cb455705c0eb8520d66eedcd 100644 (file)
@@ -229,7 +229,6 @@ void RAS_OpenGLRasterizer::SetFogColor(float r,
        m_fogr = r;
        m_fogg = g;
        m_fogb = b;
-       m_fogenabled = true;
 }
 
 
@@ -237,7 +236,6 @@ void RAS_OpenGLRasterizer::SetFogColor(float r,
 void RAS_OpenGLRasterizer::SetFogStart(float start)
 {
        m_fogstart = start;
-       m_fogenabled = true;
 }
 
 
@@ -245,7 +243,6 @@ void RAS_OpenGLRasterizer::SetFogStart(float start)
 void RAS_OpenGLRasterizer::SetFogEnd(float fogend)
 {
        m_fogdist = fogend;
-       m_fogenabled = true;
 }
 
 
@@ -261,14 +258,13 @@ void RAS_OpenGLRasterizer::SetFog(float start,
        m_fogr = r;
        m_fogg = g;
        m_fogb = b;
-       m_fogenabled = true;
 }
 
 
 
-void RAS_OpenGLRasterizer::DisableFog()
+void RAS_OpenGLRasterizer::EnableFog(bool enable)
 {
-       m_fogenabled = false;
+       m_fogenabled = enable;
 }
 
 bool RAS_OpenGLRasterizer::IsFogEnabled()
@@ -281,16 +277,12 @@ void RAS_OpenGLRasterizer::DisplayFog()
 {
        if ((m_drawingmode >= KX_SOLID) && m_fogenabled)
        {
-               float params[5];
+               float params[4] = {m_fogr, m_fogg, m_fogb, 1.0f};
                glFogi(GL_FOG_MODE, GL_LINEAR);
                glFogf(GL_FOG_DENSITY, 0.1f);
                glFogf(GL_FOG_START, m_fogstart);
                glFogf(GL_FOG_END, m_fogstart + m_fogdist);
-               params[0] = m_fogr;
-               params[1] = m_fogg;
-               params[2] = m_fogb;
-               params[3] = 0.0;
-               glFogfv(GL_FOG_COLOR, params); 
+               glFogfv(GL_FOG_COLOR, params);
                glEnable(GL_FOG);
        } 
        else
index 1334ddb2a26cf0e4d311eacb7d73a23715709c99..042243230b32559535810ad1e1c2ebd3dee79f0b 100644 (file)
@@ -202,7 +202,7 @@ public:
        virtual void SetFogColor(float r, float g, float b);
        virtual void SetFogStart(float fogstart);
        virtual void SetFogEnd(float fogend);
-       void DisableFog();
+       virtual void EnableFog(bool enable);
        virtual void DisplayFog();
        virtual bool IsFogEnabled();