Add wireframe frustrum view.

data/shaders/frustrum.vert

@@ -0,0 +1,18 @@
+layout (std140) uniform MatrixesData
+{
+    mat4 ViewMatrix;
+    mat4 ProjectionMatrix;
+    mat4 InverseViewMatrix;
+    mat4 InverseProjectionMatrix;
+    mat4 ShadowViewProjMatrixes[4];
+    vec2 screen;
+};
+
+uniform int idx;
+
+in vec3 Position;
+
+void main(void)
+{
+    gl_Position = ShadowViewProjMatrixes[idx] * vec4(Position, 1.);
+}

src/graphics/irr_driver.hpp

@@ -345,6 +345,7 @@ private:
     class STKMeshSceneNode *m_sun_interposer;
     scene::CLensFlareSceneNode *m_lensflare;
     scene::ICameraSceneNode *m_suncam;
+    scene::ICameraSceneNode *m_shadows_cam[3];
 
     std::vector<GlowData> m_glowing;
 

src/graphics/render.cpp

@@ -711,6 +711,7 @@ void IrrDriver::computeCameraMatrix(scene::ICameraSceneNode * const camnode, siz
             camnode->setFarValue(FarValues[i]);
             camnode->setNearValue(NearValues[i]);
             camnode->render();
+            m_shadows_cam[i] = camnode;
             const core::aabbox3df smallcambox = camnode->
                 getViewFrustum()->getBoundingBox();
             core::aabbox3df trackbox(vmin->toIrrVector(), vmax->toIrrVector() -
@@ -828,18 +829,59 @@ void IrrDriver::renderShadows()
     }
 }
 
+static void renderWireFrameFrustrum(const scene::SViewFrustum *frustrum, unsigned i)
+{
+    glUseProgram(MeshShader::ViewFrustrumShader::Program);
+    glBindVertexArray(MeshShader::ViewFrustrumShader::frustrumvao);
+    glBindBuffer(GL_ARRAY_BUFFER, SharedObject::frustrumvbo);
+    float tmp[24] = {
+        frustrum->getFarLeftDown().X,
+        frustrum->getFarLeftDown().Y,
+        frustrum->getFarLeftDown().Z,
+        frustrum->getFarLeftUp().X,
+        frustrum->getFarLeftUp().Y,
+        frustrum->getFarLeftUp().Z,
+        frustrum->getFarRightDown().X,
+        frustrum->getFarRightDown().Y,
+        frustrum->getFarRightDown().Z,
+        frustrum->getFarRightUp().X,
+        frustrum->getFarRightUp().Y,
+        frustrum->getFarRightUp().Z,
+        frustrum->getNearLeftDown().X,
+        frustrum->getNearLeftDown().Y,
+        frustrum->getNearLeftDown().Z,
+        frustrum->getNearLeftUp().X,
+        frustrum->getNearLeftUp().Y,
+        frustrum->getNearLeftUp().Z,
+        frustrum->getNearRightDown().X,
+        frustrum->getNearRightDown().Y,
+        frustrum->getNearRightDown().Z,
+        frustrum->getNearRightUp().X,
+        frustrum->getNearRightUp().Y,
+        frustrum->getNearRightUp().Z,
+    };
+    glBufferSubData(GL_ARRAY_BUFFER, 0, 8 * 3 * sizeof(float), tmp);
+    MeshShader::ViewFrustrumShader::setUniforms(video::SColor(255, 0, 255, 0));
+    glDrawElements(GL_LINES, 24, GL_UNSIGNED_INT, 0);
+}
+
 
 void IrrDriver::renderShadowsDebug()
 {
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
     glViewport(0, UserConfigParams::m_height / 2, UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
     m_post_processing->renderTextureLayer(m_rtts->getShadowDepthTex(), 0);
+    renderWireFrameFrustrum(m_shadows_cam[0]->getViewFrustum(), 0);
     glViewport(UserConfigParams::m_width / 2, UserConfigParams::m_height / 2, UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
     m_post_processing->renderTextureLayer(m_rtts->getShadowDepthTex(), 1);
+    renderWireFrameFrustrum(m_shadows_cam[1]->getViewFrustum(), 1);
     glViewport(0, 0, UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
     m_post_processing->renderTextureLayer(m_rtts->getShadowDepthTex(), 2);
+    renderWireFrameFrustrum(m_shadows_cam[2]->getViewFrustum(), 2);
     glViewport(UserConfigParams::m_width / 2, 0, UserConfigParams::m_width / 2, UserConfigParams::m_height / 2);
     m_post_processing->renderTextureLayer(m_rtts->getShadowDepthTex(), 3);
+    renderWireFrameFrustrum(m_shadows_cam[3]->getViewFrustum(), 3);
+    glViewport(0, 0, UserConfigParams::m_width, UserConfigParams::m_height);
 }
 
 // ----------------------------------------------------------------------------

src/graphics/shaders.cpp

@@ -169,6 +169,26 @@ static void initCubeVBO()
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * 6 * sizeof(int), indices, GL_STATIC_DRAW);
 }
 
+GLuint SharedObject::frustrumvbo = 0;
+GLuint SharedObject::frustrumindexes = 0;
+
+static void initFrustrumVBO()
+{
+    glGenBuffers(1, &SharedObject::frustrumvbo);
+    glBindBuffer(GL_ARRAY_BUFFER, SharedObject::frustrumvbo);
+    glBufferData(GL_ARRAY_BUFFER, 8 * 3 * sizeof(float), 0, GL_DYNAMIC_DRAW);
+
+    int indices[24] = {
+        0, 1, 1, 3, 3, 2, 2, 0,
+        4, 5, 5, 7, 7, 6, 6, 4,
+        0, 4, 1, 5, 2, 6, 3, 7,
+    };
+
+    glGenBuffers(1, &SharedObject::frustrumindexes);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, SharedObject::frustrumindexes);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 12 * 2 * sizeof(int), indices, GL_STATIC_DRAW);
+}
+
 GLuint SharedObject::ViewProjectionMatrixesUBO;
 
 static void initShadowVPMUBO()
@@ -271,6 +291,7 @@ void Shaders::loadShaders()
     initQuadBuffer();
     initBillboardVBO();
     initCubeVBO();
+    initFrustrumVBO();
     initShadowVPMUBO();
     FullScreenShader::BloomBlendShader::init();
     FullScreenShader::BloomShader::init();
@@ -341,6 +362,7 @@ void Shaders::loadShaders()
     MeshShader::InstancedRefShadowShader::init();
     MeshShader::GrassShadowShader::init();
     MeshShader::SkyboxShader::init();
+    MeshShader::ViewFrustrumShader::init();
     ParticleShader::FlipParticleRender::init();
     ParticleShader::HeightmapSimulationShader::init();
     ParticleShader::SimpleParticleRender::init();
@@ -1794,6 +1816,41 @@ namespace MeshShader
         glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
         glUniform1i(uniform_tex, TU_tex);
     }
+
+    GLuint ViewFrustrumShader::Program;
+    GLuint ViewFrustrumShader::attrib_position;
+    GLuint ViewFrustrumShader::uniform_color;
+    GLuint ViewFrustrumShader::uniform_idx;
+    GLuint ViewFrustrumShader::frustrumvao;
+
+    void ViewFrustrumShader::init()
+    {
+        Program = LoadProgram(
+            GL_VERTEX_SHADER, file_manager->getAsset("shaders/frustrum.vert").c_str(),
+            GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/coloredquad.frag").c_str());
+        attrib_position = glGetAttribLocation(Program, "Position");
+        if (!UserConfigParams::m_ubo_disabled)
+        {
+            GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
+            glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
+        }
+        uniform_color = glGetUniformLocation(Program, "color");
+        uniform_idx = glGetUniformLocation(Program, "idx");
+
+        glGenVertexArrays(1, &frustrumvao);
+        glBindVertexArray(frustrumvao);
+        glBindBuffer(GL_ARRAY_BUFFER, SharedObject::frustrumvbo);
+        glEnableVertexAttribArray(attrib_position);
+        glVertexAttribPointer(attrib_position, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, SharedObject::frustrumindexes);
+        glBindVertexArray(0);
+    }
+
+    void ViewFrustrumShader::setUniforms(const video::SColor &color, unsigned idx)
+    {
+        glUniform4i(uniform_color, color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());
+        glUniform1i(uniform_idx, idx);
+    }
 }
 
 namespace LightShader

src/graphics/shaders.hpp

@@ -29,7 +29,7 @@ class SharedObject
 {
 public:
     static GLuint billboardvbo;
-    static GLuint cubevbo, cubeindexes;
+    static GLuint cubevbo, cubeindexes, frustrumvbo, frustrumindexes;
     static GLuint ViewProjectionMatrixesUBO;
 };
 
@@ -424,6 +424,18 @@ public:
     static void setUniforms(const core::matrix4 &ModelMatrix, const core::vector2df &screen, unsigned TU_tex);
 };
 
+class ViewFrustrumShader
+{
+public:
+    static GLuint Program;
+    static GLuint attrib_position;
+    static GLuint uniform_color, uniform_idx;
+    static GLuint frustrumvao;
+
+    static void init();
+    static void setUniforms(const video::SColor &color, unsigned idx);
+};
+
 }
 
 #define MAXLIGHT 32