Port also other shaders to use #stk_include

data/shaders/IBL.frag

@@ -4,10 +4,10 @@ uniform sampler2D dtex;
 out vec4 Diff;
 out vec4 Spec;
 
-vec3 DecodeNormal(vec2 n);
+#stk_include "utils/decodeNormal.frag"
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
-vec3 DiffuseIBL(vec3 normal);
+#stk_include "utils/DiffuseIBL.frag"
-vec3 SpecularIBL(vec3 normal, vec3 V, float roughness);
+#stk_include "utils/SpecularIBL.frag"
 
 void main(void)
 {

data/shaders/Lightspaceboundingbox.comp

@@ -22,7 +22,7 @@ layout (std430) buffer BoundingBoxes
     CascadeBoundingBox BB[4];
 };
 
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
 
 shared int xmin[4];
 shared int xmax[4];

data/shaders/bloom.frag

@@ -2,8 +2,8 @@ uniform sampler2D tex;
 
 out vec4 FragColor;
 
-vec3 getCIEYxy(vec3 rgbColor);
+#stk_include "utils/getCIEXYZ.frag"
-vec3 getRGBFromCIEXxy(vec3 YxyColor);
+#stk_include "utils/getRGBfromCIEXxy.frag"
 
 void main()
 {

data/shaders/degraded_ibl.frag

@@ -3,10 +3,10 @@ uniform sampler2D ntex;
 out vec4 Diff;
 out vec4 Spec;
 
-vec3 DecodeNormal(vec2 n);
+#stk_include "utils/decodeNormal.frag"
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
-vec3 DiffuseIBL(vec3 normal);
+#stk_include "utils/DiffuseIBL.frag"
-vec3 SpecularIBL(vec3 normal, vec3 V, float roughness);
+#stk_include "utils/SpecularIBL.frag"
 
 void main(void)
 {

data/shaders/fog.frag

@@ -6,7 +6,7 @@ uniform vec3 col;
 out vec4 FragColor;
 
 
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
 
 void main()
 {

data/shaders/gi.frag

@@ -14,7 +14,7 @@ uniform mat4 RHMatrix;
 uniform mat4 InvRHMatrix;
 
 vec4 SHBasis (const in vec3 dir)
-{ 
+{
     float   L00  = 0.282095;
     float   L1_1 = 0.488603 * dir.y;
     float   L10  = 0.488603 * dir.z;
@@ -30,8 +30,8 @@ vec3 SH2RGB (in vec4 sh_r, in vec4 sh_g, in vec4 sh_b, in vec3 dir)
 
 out vec4 Diffuse;
 
-vec3 DecodeNormal(vec2 n);
+#stk_include "utils/decodeNormal.frag"
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
 
 vec3 resolution = vec3(32, 16, 32);
 

data/shaders/glow_object.vert

@@ -12,8 +12,7 @@ layout(location = 12) in vec4 GlowColor;
 
 flat out vec4 glowColor;
 
-mat4 getWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
+#stk_include "utils/getworldmatrix.vert"
-mat4 getInverseWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
 
 void main(void)
 {

data/shaders/instanced_detailed_object_pass2.frag

@@ -13,7 +13,7 @@ in vec2 uv;
 in vec2 uv_bis;
 out vec4 FragColor;
 
-vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
+#stk_include "utils/getLightFactor.frag"
 
 void main(void)
 {

data/shaders/instanced_grass.vert

@@ -32,8 +32,7 @@ flat out sampler2D handle;
 flat out sampler2D secondhandle;
 #endif
 
-mat4 getWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
+#stk_include "utils/getworldmatrix.vert"
-mat4 getInverseWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
 
 void main()
 {

data/shaders/instanced_grass_pass2.frag

@@ -14,7 +14,7 @@ in vec3 nor;
 in vec2 uv;
 out vec4 FragColor;
 
-vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
+#stk_include "utils/getLightFactor.frag"
 
 void main(void)
 {

data/shaders/instanced_normalmap.frag

@@ -12,7 +12,7 @@ in vec3 bitangent;
 in vec2 uv;
 out vec3 EncodedNormal;
 
-vec2 EncodeNormal(vec3 n);
+#stk_include "utils/encode_normal.frag"
 
 void main()
 {

data/shaders/instanced_object_pass.vert

@@ -42,8 +42,7 @@ flat out sampler2D secondhandle;
 flat out sampler2D thirdhandle;
 #endif
 
-mat4 getWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
+#stk_include "utils/getworldmatrix.vert"
-mat4 getInverseWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
 
 void main(void)
 {

data/shaders/instanced_object_pass1.frag

@@ -9,7 +9,7 @@ in vec3 nor;
 in vec2 uv;
 out vec3 EncodedNormal;
 
-vec2 EncodeNormal(vec3 n);
+#stk_include "utils/encode_normal.frag"
 
 void main(void)
 {

data/shaders/instanced_object_pass2.frag

@@ -11,7 +11,7 @@ in vec2 uv;
 in vec4 color;
 out vec4 FragColor;
 
-vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
+#stk_include "utils/getLightFactor.frag"
 
 void main(void)
 {
@@ -28,6 +28,6 @@ void main(void)
     float emitmap = texture(SpecMap, uv).b;
 #endif
     col.xyz *= pow(color.xyz, vec3(2.2));
-    
+
     FragColor = vec4(getLightFactor(col.xyz, vec3(1.), specmap, emitmap) , 1.);
 }

data/shaders/instanced_objectpass_spheremap.frag

@@ -10,9 +10,8 @@ flat in sampler2D handle;
 in vec3 nor;
 out vec4 FragColor;
 
-
+#stk_include "utils/getPosFromUVDepth.frag"
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getLightFactor.frag"
-vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
 
 void main() {
     vec3 texc = gl_FragCoord.xyz / vec3(screen, 1.);

data/shaders/instanced_objectref_pass1.frag

@@ -11,7 +11,7 @@ in vec3 nor;
 in vec2 uv;
 out vec3 EncodedNormal;
 
-vec2 EncodeNormal(vec3 n);
+#stk_include "utils/encode_normal.frag"
 
 void main() {
 #ifdef Use_Bindless_Texture

data/shaders/instanced_objectref_pass2.frag

@@ -11,7 +11,7 @@ in vec2 uv;
 in vec4 color;
 out vec4 FragColor;
 
-vec3 getLightFactor(vec3 diffuseMatColor, vec3 specularMatColor, float specMapValue, float emitMapValue);
+#stk_include "utils/getLightFactor.frag"
 
 void main(void)
 {

data/shaders/instanced_rsm.vert

@@ -21,8 +21,7 @@ flat out uvec2 handle;
 #endif
 
 
-mat4 getWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
+#stk_include "utils/getworldmatrix.vert"
-mat4 getInverseWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
 
 void main(void)
 {

data/shaders/instanciedgrassshadow.vert

@@ -36,8 +36,7 @@ flat out uvec2 hdle;
 #endif
 #endif
 
-mat4 getWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
+#stk_include "utils/getworldmatrix.vert"
-mat4 getInverseWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
 
 void main(void)
 {
@@ -57,4 +56,4 @@ void main(void)
     hdle = Handle;
 #endif
 #endif
-}
+}

data/shaders/instanciedshadow.vert

@@ -33,8 +33,7 @@ flat out uvec2 hdle;
 #endif
 #endif
 
-mat4 getWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
+#stk_include "utils/getworldmatrix.vert"
-mat4 getInverseWorldMatrix(vec3 translation, vec3 rotation, vec3 scale);
 
 void main(void)
 {
@@ -54,4 +53,4 @@ void main(void)
     hdle = Handle;
 #endif
 #endif
-}
+}

data/shaders/motion_blur.frag

@@ -42,7 +42,7 @@ out vec4 FragColor;
 // Number of samples used for blurring
 #define NB_SAMPLES 8
 
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
 
 void main()
 {

data/shaders/pointlight.frag

@@ -9,10 +9,10 @@ flat in float radius;
 out vec4 Diff;
 out vec4 Spec;
 
-vec3 DecodeNormal(vec2 n);
+#stk_include "utils/decodeNormal.frag"
-vec3 SpecularBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+#stk_include "utils/SpecularBRDF.frag"
-vec3 DiffuseBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+#stk_include "utils/DiffuseBRDF.frag"
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
 
 void main()
 {

data/shaders/pointlightscatter.frag

@@ -9,7 +9,7 @@ flat in float radius;
 
 out vec4 Fog;
 
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
 
 void main()
 {

data/shaders/sunlight.frag

@@ -4,11 +4,11 @@ uniform sampler2D dtex;
 out vec4 Diff;
 out vec4 Spec;
 
-vec3 DecodeNormal(vec2 n);
+#stk_include "utils/decodeNormal.frag"
-vec3 SpecularBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+#stk_include "utils/SpecularBRDF.frag"
-vec3 DiffuseBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+#stk_include "utils/DiffuseBRDF.frag"
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
-vec3 SunMRP(vec3 normal, vec3 eyedir);
+#stk_include "utils/SunMRP.frag"
 
 void main() {
     vec2 uv = gl_FragCoord.xy / screen;

data/shaders/sunlightshadow.frag

@@ -12,11 +12,11 @@ in vec2 uv;
 out vec4 Diff;
 out vec4 Spec;
 
-vec3 DecodeNormal(vec2 n);
+#stk_include "utils/decodeNormal.frag"
-vec3 SpecularBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+#stk_include "utils/SpecularBRDF.frag"
-vec3 DiffuseBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+#stk_include "utils/DiffuseBRDF.frag"
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
-vec3 SunMRP(vec3 normal, vec3 eyedir);
+#stk_include "utils/SunMRP.frag"
 
 float getShadowFactor(vec3 pos, int index)
 {

data/shaders/sunlightshadowesm.frag

@@ -11,11 +11,11 @@ in vec2 uv;
 out vec4 Diff;
 out vec4 Spec;
 
-vec3 DecodeNormal(vec2 n);
+#stk_include "utils/decodeNormal.frag"
-vec3 SpecularBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+#stk_include "utils/SpecularBRDF.frag"
-vec3 DiffuseBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float roughness);
+#stk_include "utils/DiffuseBRDF.frag"
-vec4 getPosFromUVDepth(vec3 uvDepth, mat4 InverseProjectionMatrix);
+#stk_include "utils/getPosFromUVDepth.frag"
-vec3 SunMRP(vec3 normal, vec3 eyedir);
+#stk_include "utils/SunMRP.frag"
 
 float getShadowFactor(vec3 pos, int index)
 {

data/shaders/untextured_object.frag

@@ -2,7 +2,7 @@
 in vec4 color;
 out vec4 FragColor;
 
-vec3 getLightFactor(float specMapValue);
+#stk_include "utils/getLightFactor.frag"
 
 void main(void)
 {

data/shaders/utils/SpecularBRDF.frag

@@ -6,6 +6,6 @@ vec3 SpecularBRDF(vec3 normal, vec3 eyedir, vec3 lightdir, vec3 color, float rou
     vec3 H = normalize(eyedir + lightdir);
     float NdotH = clamp(dot(normal, H), 0., 1.);
     float normalisationFactor = (exponentroughness + 2.) / 8.;
-    vec3 FresnelSchlick = color + (1.0f - color) * pow(1.0f - clamp(dot(eyedir, H), 0., 1.), 5);
+    vec3 FresnelSchlick = color + (1.0f - color) * pow(1.0f - clamp(dot(eyedir, H), 0., 1.), 5.);
     return max(pow(NdotH, exponentroughness) * FresnelSchlick * normalisationFactor, vec3(0.));
-}
+}

src/graphics/gpu_particles.cpp

@@ -81,7 +81,6 @@ public:
     {
         loadProgram(PARTICLES_RENDERING,
                     GL_VERTEX_SHADER,   "flipparticle.vert",
-                    GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
                     GL_FRAGMENT_SHADER, "particle.frag");
         assignUniforms();
         assignSamplerNames(0, "tex",  ST_TRILINEAR_ANISOTROPIC_FILTERED,
@@ -148,7 +147,7 @@ ParticleSystemProxy::ParticleSystemProxy(bool createDefaultEmitter,
 
     m_color_from[0] = m_color_from[1] = m_color_from[2] = 1.0;
     m_color_to[0] = m_color_to[1] = m_color_to[2] = 1.0;
-    
+
     // We set these later but avoid coverity report them
     heighmapbuffer = 0;
     heightmaptexture = 0;
@@ -264,7 +263,7 @@ void ParticleSystemProxy::generateParticlesFromPointEmitter(scene::IParticlePoin
         ParticleParams[i].PositionZ = 0;
         // Initial lifetime is >1
         InitialValues[i].Lifetime = 2.;
-        
+
         memcpy(&(InitialValues[i].PositionX), &(ParticleParams[i].PositionX), 3 * sizeof(float));
 
         generateLifetimeSizeDirection(emitter, ParticleParams[i].Lifetime, ParticleParams[i].Size,
@@ -474,12 +473,12 @@ void ParticleSystemProxy::CommonSimulationVAO(GLuint position_vbo, GLuint initia
 }
 
 void ParticleSystemProxy::simulate()
-{    
+{
 #ifndef ANDROID
     int timediff = int(GUIEngine::getLatestDt() * 1000.f);
     int active_count = getEmitter()->getMaxLifeTime() * getEmitter()->getMaxParticlesPerSecond() / 1000;
     core::matrix4 matrix = getAbsoluteTransformation();
-    
+
     glEnable(GL_RASTERIZER_DISCARD);
     if (has_height_map)
     {
@@ -494,7 +493,7 @@ void ParticleSystemProxy::simulate()
         PointEmitterShader::getInstance()->setUniforms(m_previous_frame_matrix, matrix, timediff, active_count, size_increase_factor);
     }
     m_previous_frame_matrix = matrix;
-    
+
     glBindVertexArray(current_simulation_vao);
     glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfb_buffers[1]);
 

src/graphics/post_processing.cpp

@@ -147,7 +147,7 @@ public:
 
 // ============================================================================
 class ComputeGaussian6HBlurShader : public TextureShader<ComputeGaussian6HBlurShader, 1,
-                                                  core::vector2df, 
+                                                  core::vector2df,
                                                   std::vector<float> >
 {
 public:
@@ -282,7 +282,7 @@ public:
 };   // Gaussian17TapVShader
 
 // ============================================================================
-class ComputeGaussian17TapVShader : public TextureShader<ComputeGaussian17TapVShader, 2, 
+class ComputeGaussian17TapVShader : public TextureShader<ComputeGaussian17TapVShader, 2,
                                                   core::vector2df>
 {
 public:
@@ -298,7 +298,7 @@ public:
         assignTextureUnit(m_dest_tu, "dest");
     }   // ComputeGaussian17TapVShader
     // ------------------------------------------------------------------------
-    void render(const FrameBuffer &auxiliary, const FrameBuffer &fb, 
+    void render(const FrameBuffer &auxiliary, const FrameBuffer &fb,
                 int width, int height)
     {
         use();
@@ -320,8 +320,6 @@ public:
     BloomShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/getCIEXYZ.frag",
-                            GL_FRAGMENT_SHADER, "utils/getRGBfromCIEXxy.frag",
                             GL_FRAGMENT_SHADER, "bloom.frag");
         assignUniforms();
         assignSamplerNames(0, "tex", ST_NEAREST_FILTERED);
@@ -440,10 +438,6 @@ public:
     IBLShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/decodeNormal.frag",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
-                            GL_FRAGMENT_SHADER, "utils/DiffuseIBL.frag",
-                            GL_FRAGMENT_SHADER, "utils/SpecularIBL.frag",
                             GL_FRAGMENT_SHADER, "IBL.frag");
         assignUniforms();
         assignSamplerNames(0, "ntex",  ST_NEAREST_FILTERED,
@@ -459,10 +453,6 @@ public:
     DegradedIBLShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/decodeNormal.frag",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
-                            GL_FRAGMENT_SHADER, "utils/DiffuseIBL.frag",
-                            GL_FRAGMENT_SHADER, "utils/SpecularIBL.frag",
                             GL_FRAGMENT_SHADER, "degraded_ibl.frag");
         assignUniforms();
         assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED);
@@ -483,13 +473,13 @@ public:
         m_tu_shr = 0;
         m_tu_shg = 1;
         m_tu_shb = 2;
-        assignTextureUnit(m_tu_shr, "SHR",  m_tu_shg, "SHG", 
+        assignTextureUnit(m_tu_shr, "SHR",  m_tu_shg, "SHG",
                           m_tu_shb, "SHB");
     }   // RHDebug
 };   // RHDebug
 
 // ============================================================================
-class GlobalIlluminationReconstructionShader 
+class GlobalIlluminationReconstructionShader
     : public TextureShader<GlobalIlluminationReconstructionShader, 5,
                            core::matrix4, core::matrix4, core::vector3df >
 {
@@ -497,8 +487,6 @@ public:
     GlobalIlluminationReconstructionShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/decodeNormal.frag",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
                             GL_FRAGMENT_SHADER, "gi.frag");
 
         assignUniforms("rh_matrix", "inv_rh_matrix", "extents");
@@ -627,8 +615,6 @@ public:
     SSAOShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/decodeNormal.frag",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
                             GL_FRAGMENT_SHADER, "ssao.frag");
 
         assignUniforms("radius", "k", "sigma");
@@ -656,7 +642,6 @@ public:
     MotionBlurShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
                             GL_FRAGMENT_SHADER, "motion_blur.frag");
         assignUniforms("previous_viewproj", "center", "boost_amount",
                         "mask_radius");
@@ -716,7 +701,7 @@ public:
 };   // GodRayShader
 
 // ============================================================================
-class MLAAColorEdgeDetectionSHader 
+class MLAAColorEdgeDetectionSHader
     : public TextureShader<MLAAColorEdgeDetectionSHader, 1, core::vector2df>
 {
 public:
@@ -793,11 +778,6 @@ public:
     SunLightShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/decodeNormal.frag",
-                            GL_FRAGMENT_SHADER, "utils/SpecularBRDF.frag",
-                            GL_FRAGMENT_SHADER, "utils/DiffuseBRDF.frag",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
-                            GL_FRAGMENT_SHADER, "utils/SunMRP.frag",
                             GL_FRAGMENT_SHADER, "sunlight.frag");
 
         assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED,
@@ -819,7 +799,7 @@ public:
 };   // SunLightShader
 
 // ============================================================================
-class LightningShader : public TextureShader<LightningShader, 1, 
+class LightningShader : public TextureShader<LightningShader, 1,
                                              core::vector3df>
 {
 public:
@@ -885,7 +865,7 @@ void PostProcessing::reset()
     m_center.resize(n);
     m_direction.resize(n);
 
-    MotionBlurProvider * const cb = 
+    MotionBlurProvider * const cb =
         (MotionBlurProvider *) Shaders::getCallback(ES_MOTIONBLUR);
 
     for(unsigned int i=0; i<n; i++)
@@ -945,7 +925,7 @@ void PostProcessing::reset()
 // ----------------------------------------------------------------------------
 void PostProcessing::setMotionBlurCenterY(const u32 num, const float y)
 {
-    MotionBlurProvider * const cb = 
+    MotionBlurProvider * const cb =
         (MotionBlurProvider *) Shaders::getCallback(ES_MOTIONBLUR);
 
     const float tex_height =
@@ -1108,10 +1088,10 @@ static std::vector<float> getGaussianWeight(float sigma, size_t count)
 }   // getGaussianWeight
 
 // ----------------------------------------------------------------------------
-void PostProcessing::renderGaussian3Blur(const FrameBuffer &in_fbo, 
+void PostProcessing::renderGaussian3Blur(const FrameBuffer &in_fbo,
                                          const FrameBuffer &auxiliary)
 {
-    assert(in_fbo.getWidth() == auxiliary.getWidth() && 
+    assert(in_fbo.getWidth() == auxiliary.getWidth() &&
            in_fbo.getHeight() == auxiliary.getHeight());
     float inv_width  = 1.0f / in_fbo.getWidth();
     float inv_height = 1.0f / in_fbo.getHeight();
@@ -1143,13 +1123,13 @@ void PostProcessing::renderGaussian6BlurLayer(FrameBuffer &in_fbo,
         // Used as temp
         irr_driver->getFBO(FBO_SCALAR_1024).bind();
         Gaussian6VBlurShader::getInstance()
-            ->render(layer_tex, UserConfigParams::m_shadows_resolution, 
+            ->render(layer_tex, UserConfigParams::m_shadows_resolution,
                      UserConfigParams::m_shadows_resolution, sigma_v);
 
         in_fbo.bindLayer(layer);
         Gaussian6HBlurShader::getInstance()
             ->render(irr_driver->getFBO(FBO_SCALAR_1024),
-                     UserConfigParams::m_shadows_resolution, 
+                     UserConfigParams::m_shadows_resolution,
                      UserConfigParams::m_shadows_resolution, sigma_h);
     }
     else
@@ -1170,7 +1150,7 @@ void PostProcessing::renderGaussian6BlurLayer(FrameBuffer &in_fbo,
                           (int)UserConfigParams::m_shadows_resolution / 8 + 1, 1);
 
         const std::vector<float> &weightsH = getGaussianWeight(sigma_h, 7);
-        glMemoryBarrier(  GL_TEXTURE_FETCH_BARRIER_BIT 
+        glMemoryBarrier(  GL_TEXTURE_FETCH_BARRIER_BIT
                         | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
         ComputeShadowBlurHShader::getInstance()->use();
         ComputeShadowBlurHShader::getInstance()
@@ -1194,7 +1174,7 @@ void PostProcessing::renderGaussian6Blur(const FrameBuffer &in_fbo,
                                          const FrameBuffer &auxiliary, float sigma_v,
                                          float sigma_h)
 {
-    assert(in_fbo.getWidth() == auxiliary.getWidth() && 
+    assert(in_fbo.getWidth() == auxiliary.getWidth() &&
            in_fbo.getHeight() == auxiliary.getHeight());
     float inv_width = 1.0f / in_fbo.getWidth();
     float inv_height = 1.0f / in_fbo.getHeight();
@@ -1224,11 +1204,11 @@ void PostProcessing::renderGaussian6Blur(const FrameBuffer &in_fbo,
                             GL_WRITE_ONLY, GL_RGBA16F);
         ComputeGaussian6VBlurShader::getInstance()
             ->setUniforms(core::vector2df(inv_width, inv_height), weightsV);
-        glDispatchCompute((int)in_fbo.getWidth() / 8 + 1, 
+        glDispatchCompute((int)in_fbo.getWidth() / 8 + 1,
                           (int)in_fbo.getHeight() / 8 + 1, 1);
 
         const std::vector<float> &weightsH = getGaussianWeight(sigma_h, 7);
-        glMemoryBarrier(  GL_TEXTURE_FETCH_BARRIER_BIT 
+        glMemoryBarrier(  GL_TEXTURE_FETCH_BARRIER_BIT
                         | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
         ComputeGaussian6HBlurShader::getInstance()->use();
         ComputeGaussian6HBlurShader::getInstance()
@@ -1299,7 +1279,7 @@ void PostProcessing::renderGaussian17TapBlur(const FrameBuffer &in_fbo,
         else
         {
             ComputeGaussian17TapVShader::getInstance()->render(auxiliary,
-                                                               in_fbo, 
+                                                               in_fbo,
                                                                in_fbo.getWidth(),
                                                                in_fbo.getHeight());
         }
@@ -1432,9 +1412,9 @@ void PostProcessing::renderLightning(core::vector3df intensity)
     glEnable(GL_BLEND);
     glBlendFunc(GL_ONE, GL_ONE);
     glBlendEquation(GL_FUNC_ADD);
-       
+
     LightningShader::getInstance()->render(intensity);
-    
+
     glDisable(GL_BLEND);
 }
 
@@ -1513,9 +1493,9 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
 
             trans.transformVect(ndc, pos);
 
-            const float texh = 
+            const float texh =
                 m_vertices[0].v1.TCoords.Y - m_vertices[0].v0.TCoords.Y;
-            const float texw = 
+            const float texw =
                 m_vertices[0].v3.TCoords.X - m_vertices[0].v0.TCoords.X;
 
             const float sunx = ((ndc[0] / ndc[3]) * 0.5f + 0.5f) * texw;
@@ -1564,7 +1544,7 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
 
             // Downsample
             FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_512),
-                              irr_driver->getFBO(FBO_BLOOM_256), 
+                              irr_driver->getFBO(FBO_BLOOM_256),
                               GL_COLOR_BUFFER_BIT, GL_LINEAR);
             FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_256),
                               irr_driver->getFBO(FBO_BLOOM_128),
@@ -1572,7 +1552,7 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
 
 			// Copy for lens flare
 			FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_512),
-                              irr_driver->getFBO(FBO_LENS_512), 
+                              irr_driver->getFBO(FBO_LENS_512),
                               GL_COLOR_BUFFER_BIT, GL_LINEAR);
 			FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_256),
                               irr_driver->getFBO(FBO_LENS_256),
@@ -1580,7 +1560,7 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
 			FrameBuffer::Blit(irr_driver->getFBO(FBO_BLOOM_128),
                               irr_driver->getFBO(FBO_LENS_128),
                               GL_COLOR_BUFFER_BIT, GL_LINEAR);
-			
+
 
             // Blur
             renderGaussian6Blur(irr_driver->getFBO(FBO_BLOOM_512),
@@ -1590,20 +1570,20 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
             renderGaussian6Blur(irr_driver->getFBO(FBO_BLOOM_128),
                                 irr_driver->getFBO(FBO_TMP_128), 1., 1.);
 
-            renderHorizontalBlur(irr_driver->getFBO(FBO_LENS_512), 
+            renderHorizontalBlur(irr_driver->getFBO(FBO_LENS_512),
                                  irr_driver->getFBO(FBO_TMP_512));
             renderHorizontalBlur(irr_driver->getFBO(FBO_LENS_256),
                                  irr_driver->getFBO(FBO_TMP_256));
-            renderHorizontalBlur(irr_driver->getFBO(FBO_LENS_128), 
+            renderHorizontalBlur(irr_driver->getFBO(FBO_LENS_128),
                                  irr_driver->getFBO(FBO_TMP_128));
-            
+
 
             // Additively blend on top of tmp1
             in_fbo->bind();
             glEnable(GL_BLEND);
             glBlendFunc(GL_ONE, GL_ONE);
             glBlendEquation(GL_FUNC_ADD);
-            
+
             BloomBlendShader::getInstance()->render();
             LensBlendShader::getInstance()->render();
 
@@ -1627,7 +1607,7 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
     {
         PROFILER_PUSH_CPU_MARKER("- Motion blur", 0xFF, 0x00, 0x00);
         ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_MOTIONBLUR));
-        MotionBlurProvider * const cb = 
+        MotionBlurProvider * const cb =
             (MotionBlurProvider *)Shaders::getCallback(ES_MOTIONBLUR);
 
         if (isRace && UserConfigParams::m_motionblur && World::getWorld() &&
@@ -1638,7 +1618,7 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
         }
         PROFILER_POP_CPU_MARKER();
     }
-    
+
     // Handle lightning rendering
     {
         PROFILER_PUSH_CPU_MARKER("- Lightning", 0xFF, 0x00, 0x00);
@@ -1646,7 +1626,7 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
         if (World::getWorld() != NULL)
         {
             Weather* m_weather = World::getWorld()->getWeather();
-            
+
             if (m_weather != NULL && m_weather->shouldLightning())
             {
                 renderLightning(m_weather->getIntensity());

src/graphics/render.cpp

@@ -51,8 +51,7 @@ class InstancedColorizeShader : public Shader<InstancedColorizeShader>
 public:
     InstancedColorizeShader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER,   "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER,   "glow_object.vert",
-                            GL_VERTEX_SHADER,   "glow_object.vert",
                             GL_FRAGMENT_SHADER, "glow_object.frag");
         assignUniforms();
     }   // InstancedColorizeShader
@@ -306,7 +305,7 @@ void IrrDriver::renderGLSL(float dt)
     float tmp[2];
     tmp[0] = float(m_actual_screen_size.Width);
     tmp[1] = float(m_actual_screen_size.Height);
-    glBindBuffer(GL_UNIFORM_BUFFER, 
+    glBindBuffer(GL_UNIFORM_BUFFER,
                  SharedGPUObjects::getViewProjectionMatricesUBO());
     glBufferSubData(GL_UNIFORM_BUFFER, (16 * 9) * sizeof(float),
                     2 * sizeof(float), tmp);
@@ -501,7 +500,7 @@ void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned po
         glDisable(GL_BLEND);
         m_rtts->getFBO(FBO_COLORS).bind();
         m_post_processing->renderRHDebug(m_rtts->getRH().getRTT()[0],
-                                         m_rtts->getRH().getRTT()[1], 
+                                         m_rtts->getRH().getRTT()[1],
                                          m_rtts->getRH().getRTT()[2],
                                          getShadowMatrices()->getRHMatrix(),
                                          getShadowMatrices()->getRHExtend());

src/graphics/render_geometry.cpp

@@ -83,9 +83,7 @@ class InstancedObjectPass1Shader : public TextureShader<InstancedObjectPass1Shad
 public:
     InstancedObjectPass1Shader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_FRAGMENT_SHADER, "utils/encode_normal.frag",
                             GL_FRAGMENT_SHADER, "instanced_object_pass1.frag");
 
         assignUniforms();
@@ -99,9 +97,7 @@ class InstancedObjectRefPass1Shader : public TextureShader<InstancedObjectRefPas
 public:
     InstancedObjectRefPass1Shader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_FRAGMENT_SHADER, "utils/encode_normal.frag",
                             GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
 
         assignUniforms();
@@ -135,9 +131,7 @@ class InstancedObjectPass2Shader : public TextureShader<InstancedObjectPass2Shad
 public:
     InstancedObjectPass2Shader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
                             GL_FRAGMENT_SHADER, "instanced_object_pass2.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -154,9 +148,7 @@ class InstancedObjectRefPass2Shader : public TextureShader<InstancedObjectRefPas
 public:
     InstancedObjectRefPass2Shader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
                             GL_FRAGMENT_SHADER, "instanced_objectref_pass2.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -206,14 +198,12 @@ public:
             return;
         if (CVS->isAMDVertexShaderLayerUsable())
         {
-            loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanciedshadow.vert",
-                                GL_VERTEX_SHADER, "instanciedshadow.vert",
                                 GL_FRAGMENT_SHADER, "shadow.frag");
         }
         else
         {
-            loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanciedshadow.vert",
-                                GL_VERTEX_SHADER, "instanciedshadow.vert",
                                 GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                                 GL_FRAGMENT_SHADER, "shadow.frag");
         }
@@ -224,7 +214,7 @@ public:
 };   // InstancedShadowShader
 
 // ============================================================================
-class CRSMShader : public TextureShader<CRSMShader, 1, core::matrix4, core::matrix4, 
+class CRSMShader : public TextureShader<CRSMShader, 1, core::matrix4, core::matrix4,
                                  core::matrix4>
 {
 public:
@@ -265,8 +255,7 @@ class CInstancedRSMShader : public TextureShader<CInstancedRSMShader, 1, core::m
 public:
     CInstancedRSMShader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_rsm.vert",
-                            GL_VERTEX_SHADER, "instanced_rsm.vert",
                             GL_FRAGMENT_SHADER, "instanced_rsm.frag");
 
         assignUniforms("RSMMatrix");
@@ -297,10 +286,8 @@ class InstancedSphereMapShader : public TextureShader<InstancedSphereMapShader,
 public:
     InstancedSphereMapShader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT,
                     GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                    GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
-                    GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
                     GL_FRAGMENT_SHADER, "instanced_objectpass_spheremap.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -348,7 +335,7 @@ public:
 
 
 // ============================================================================
-class NormalMapShader : public TextureShader<NormalMapShader, 2, core::matrix4, 
+class NormalMapShader : public TextureShader<NormalMapShader, 2, core::matrix4,
                                       core::matrix4>
 {
 public:
@@ -369,9 +356,7 @@ class InstancedNormalMapShader : public TextureShader<InstancedNormalMapShader,
 public:
     InstancedNormalMapShader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_FRAGMENT_SHADER, "utils/encode_normal.frag",
                             GL_FRAGMENT_SHADER, "instanced_normalmap.frag");
         assignUniforms();
         assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@@ -380,7 +365,7 @@ public:
 };   // InstancedNormalMapShader
 
 // ============================================================================
-class ObjectUnlitShader : public TextureShader<ObjectUnlitShader, 4, core::matrix4, 
+class ObjectUnlitShader : public TextureShader<ObjectUnlitShader, 4, core::matrix4,
                                         core::matrix4>
 {
 public:
@@ -402,8 +387,7 @@ class InstancedObjectUnlitShader : public TextureShader<InstancedObjectUnlitShad
 public:
     InstancedObjectUnlitShader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_VERTEX_SHADER, "instanced_object_pass.vert",
                             GL_FRAGMENT_SHADER, "instanced_object_unlit.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -414,7 +398,7 @@ public:
 };   // InstancedObjectUnlitShader
 
 // ============================================================================
-class RefShadowShader : public TextureShader<RefShadowShader, 1, 
+class RefShadowShader : public TextureShader<RefShadowShader, 1,
                                              int, core::matrix4>
 {
 public:
@@ -454,14 +438,12 @@ public:
             return;
         if (CVS->isAMDVertexShaderLayerUsable())
         {
-            loadProgram(OBJECT,GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+            loadProgram(OBJECT,GL_VERTEX_SHADER, "instanciedshadow.vert",
-                               GL_VERTEX_SHADER, "instanciedshadow.vert",
                                GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
         }
         else
         {
-            loadProgram(OBJECT,GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+            loadProgram(OBJECT,GL_VERTEX_SHADER, "instanciedshadow.vert",
-                               GL_VERTEX_SHADER, "instanciedshadow.vert",
                                GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                                GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
         }
@@ -494,7 +476,7 @@ public:
                             GL_FRAGMENT_SHADER, "displace.frag");
         assignUniforms("ModelMatrix", "dir", "dir2");
 
-        assignSamplerNames(0, "displacement_tex", ST_BILINEAR_FILTERED, 
+        assignSamplerNames(0, "displacement_tex", ST_BILINEAR_FILTERED,
                            1, "color_tex", ST_BILINEAR_FILTERED,
                            2, "mask_tex", ST_BILINEAR_FILTERED,
                            3, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -508,8 +490,7 @@ public:
     NormalVisualizer()
     {
 #if !defined(ANDROID) && !defined(USE_GLES2)          //?????
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                            GL_VERTEX_SHADER, "instanced_object_pass.vert",
                             GL_GEOMETRY_SHADER, "normal_visualizer.geom",
                             GL_FRAGMENT_SHADER, "coloredquad.frag");
         assignUniforms("color");
@@ -572,7 +553,7 @@ struct AlphaRef
 // ----------------------------------------------------------------------------
 const STK::Tuple<size_t, size_t> AlphaRef::FirstPassTextures
     = STK::Tuple<size_t, size_t>(0, 1);
-const STK::Tuple<size_t, size_t> AlphaRef::SecondPassTextures 
+const STK::Tuple<size_t, size_t> AlphaRef::SecondPassTextures
     = STK::Tuple<size_t, size_t>(0, 1);
 const STK::Tuple<size_t> AlphaRef::ShadowTextures = STK::Tuple<size_t>(0);
 const STK::Tuple<size_t> AlphaRef::RSMTextures = STK::Tuple<size_t>(0);
@@ -591,7 +572,7 @@ struct SphereMap
     typedef CRSMShader RSMShader;
     typedef ListMatSphereMap List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
-    static const enum Material::ShaderType MaterialType 
+    static const enum Material::ShaderType MaterialType
                                           = Material::SHADERTYPE_SPHERE_MAP;
     static const enum InstanceType Instance = InstanceTypeDualTex;
     static const STK::Tuple<size_t> FirstPassTextures;
@@ -659,9 +640,7 @@ class InstancedGrassPass1Shader : public TextureShader<InstancedGrassPass1Shader
 public:
     InstancedGrassPass1Shader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_grass.vert",
-                            GL_VERTEX_SHADER, "instanced_grass.vert",
-                            GL_FRAGMENT_SHADER, "utils/encode_normal.frag",
                             GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
         assignUniforms("windDir");
         assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@@ -698,7 +677,7 @@ public:
 };   // GrassShadowShader
 
 // ============================================================================
-class InstancedGrassShadowShader : public TextureShader<InstancedGrassShadowShader, 1, 
+class InstancedGrassShadowShader : public TextureShader<InstancedGrassShadowShader, 1,
                                                  int, core::vector3df>
 {
 public:
@@ -710,14 +689,12 @@ public:
             return;
         if (CVS->isAMDVertexShaderLayerUsable())
         {
-            loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanciedgrassshadow.vert",
-                                GL_VERTEX_SHADER, "instanciedgrassshadow.vert",
                                 GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
         }
         else
         {
-            loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanciedgrassshadow.vert",
-                                GL_VERTEX_SHADER, "instanciedgrassshadow.vert",
                                 GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                                 GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
         }
@@ -754,9 +731,7 @@ class InstancedGrassPass2Shader : public TextureShader<InstancedGrassPass2Shader
 public:
     InstancedGrassPass2Shader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_grass.vert",
-                            GL_VERTEX_SHADER, "instanced_grass.vert",
-                            GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
                             GL_FRAGMENT_SHADER, "instanced_grass_pass2.frag");
         assignUniforms("windDir", "SunDir");
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -793,9 +768,8 @@ class InstancedDetailedObjectPass2Shader : public TextureShader<InstancedDetaile
 public:
     InstancedDetailedObjectPass2Shader()
     {
-        loadProgram(OBJECT, GL_VERTEX_SHADER, "utils/getworldmatrix.vert",
+        loadProgram(OBJECT,
                    GL_VERTEX_SHADER, "instanced_object_pass.vert",
-                   GL_FRAGMENT_SHADER, "utils/getLightFactor.frag",
                    GL_FRAGMENT_SHADER, "instanced_detailed_object_pass2.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -825,7 +799,7 @@ struct GrassMat
     typedef CRSMShader RSMShader;
     typedef ListMatGrass List;
     static const enum video::E_VERTEX_TYPE VertexType = video::EVT_STANDARD;
-    static const enum Material::ShaderType MaterialType 
+    static const enum Material::ShaderType MaterialType
         = Material::SHADERTYPE_VEGETATION;
     static const enum InstanceType Instance = InstanceTypeDualTex;
     static const STK::Tuple<size_t, size_t> FirstPassTextures;
@@ -835,9 +809,9 @@ struct GrassMat
 };   // GrassMat
 
 // ----------------------------------------------------------------------------
-const STK::Tuple<size_t, size_t> GrassMat::FirstPassTextures 
+const STK::Tuple<size_t, size_t> GrassMat::FirstPassTextures
     = STK::Tuple<size_t, size_t>(0, 1);
-const STK::Tuple<size_t, size_t> GrassMat::SecondPassTextures 
+const STK::Tuple<size_t, size_t> GrassMat::SecondPassTextures
     = STK::Tuple<size_t, size_t>(0, 1);
 const STK::Tuple<size_t> GrassMat::ShadowTextures = STK::Tuple<size_t>(0);
 const STK::Tuple<size_t> GrassMat::RSMTextures = STK::Tuple<size_t>(0);
@@ -868,7 +842,7 @@ struct NormalMat
 // ----------------------------------------------------------------------------
 const STK::Tuple<size_t, size_t> NormalMat::FirstPassTextures
     = STK::Tuple<size_t, size_t>(2, 1);
-const STK::Tuple<size_t, size_t> NormalMat::SecondPassTextures 
+const STK::Tuple<size_t, size_t> NormalMat::SecondPassTextures
     = STK::Tuple<size_t, size_t>(0, 1);
 const STK::Tuple<> NormalMat::ShadowTextures;
 const STK::Tuple<size_t> NormalMat::RSMTextures = STK::Tuple<size_t>(0);
@@ -921,8 +895,8 @@ struct SplattingMat
 // ----------------------------------------------------------------------------
 
 const STK::Tuple<size_t> SplattingMat::FirstPassTextures = STK::Tuple<size_t>(6);
-const STK::Tuple<size_t, size_t, size_t, size_t, size_t> 
+const STK::Tuple<size_t, size_t, size_t, size_t, size_t>
-          SplattingMat::SecondPassTextures 
+          SplattingMat::SecondPassTextures
               = STK::Tuple<size_t, size_t, size_t, size_t, size_t>(1, 2, 3, 4, 5);
 const STK::Tuple<> SplattingMat::ShadowTextures;
 const STK::Tuple<size_t, size_t, size_t, size_t, size_t> SplattingMat::RSMTextures
@@ -1037,7 +1011,7 @@ struct TexExpander_impl
     {
         size_t idx = STK::tuple_get<sizeof...(TupleArgs) - N>(TexSwizzle);
         TexExpander_impl<T, N - 1>::template
-            ExpandTex(mesh, TexSwizzle, 
+            ExpandTex(mesh, TexSwizzle,
                       args..., getTextureGLuint(mesh.textures[idx]));
     }   // ExpandTex
 };   // TexExpander_impl
@@ -1072,11 +1046,11 @@ template<typename T, int N>
 struct HandleExpander_impl
 {
     template<typename...TupleArgs, typename... Args>
-    static void Expand(uint64_t *TextureHandles, 
+    static void Expand(uint64_t *TextureHandles,
                        const STK::Tuple<TupleArgs...> &TexSwizzle, Args... args)
     {
         size_t idx = STK::tuple_get<sizeof...(TupleArgs)-N>(TexSwizzle);
-        HandleExpander_impl<T, N - 1>::template 
+        HandleExpander_impl<T, N - 1>::template
             Expand(TextureHandles, TexSwizzle, args..., TextureHandles[idx]);
     }   // Expand
 };   // HandleExpander_impl
@@ -1149,7 +1123,7 @@ void renderInstancedMeshes1stPass(Args...args)
 #ifdef DEBUG
         if (mesh->VAOType != T::VertexType)
         {
-            Log::error("RenderGeometry", "Wrong instanced vertex format (hint : %s)", 
+            Log::error("RenderGeometry", "Wrong instanced vertex format (hint : %s)",
                 mesh->textures[0]->getName().getPath().c_str());
             continue;
         }
@@ -1248,22 +1222,22 @@ void renderMeshes2ndPass( const std::vector<uint64_t> &Prefilled_Handle,
         {
 #ifdef DEBUG
             Log::error("Materials", "Wrong vertex Type associed to pass 2 "
-                                    "(hint texture : %s)", 
+                                    "(hint texture : %s)",
                        mesh.textures[0]->getName().getPath().c_str());
 #endif
             continue;
         }
 
         if (CVS->isAZDOEnabled())
-            HandleExpander<typename T::SecondPassShader>::template 
+            HandleExpander<typename T::SecondPassShader>::template
-                Expand(mesh.TextureHandles, T::SecondPassTextures, 
+                Expand(mesh.TextureHandles, T::SecondPassTextures,
                        Prefilled_Handle[0], Prefilled_Handle[1],
                        Prefilled_Handle[2]);
         else
-            TexExpander<typename T::SecondPassShader>::template 
+            TexExpander<typename T::SecondPassShader>::template
-                ExpandTex(mesh, T::SecondPassTextures, Prefilled_Tex[0], 
+                ExpandTex(mesh, T::SecondPassTextures, Prefilled_Tex[0],
                           Prefilled_Tex[1], Prefilled_Tex[2]);
-        custom_unroll_args<List...>::template 
+        custom_unroll_args<List...>::template
             exec(T::SecondPassShader::getInstance(), meshes.at(i));
     }
 }   // renderMeshes2ndPass
@@ -1283,7 +1257,7 @@ void renderInstancedMeshes2ndPass(const std::vector<GLuint> &Prefilled_tex, Args
             ExpandTex(*mesh, T::SecondPassTextures, Prefilled_tex[0],
                       Prefilled_tex[1], Prefilled_tex[2]);
         T::InstancedSecondPassShader::getInstance()->setUniforms(args...);
-        glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, 
+        glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
            (const void*)((SolidPassCmd::getInstance()->Offset[T::MaterialType] + i)
            * sizeof(DrawElementsIndirectCommand)));
     }
@@ -1305,7 +1279,7 @@ void multidraw2ndPass(const std::vector<uint64_t> &Handles, Args... args)
                    Handles[2]);
         T::InstancedSecondPassShader::getInstance()->setUniforms(args...);
         glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
-            (const void*)(SolidPassCmd::getInstance()->Offset[T::MaterialType] 
+            (const void*)(SolidPassCmd::getInstance()->Offset[T::MaterialType]
              * sizeof(DrawElementsIndirectCommand)),
             (int)SolidPassCmd::getInstance()->Size[T::MaterialType],
             (int)sizeof(DrawElementsIndirectCommand));
@@ -1359,8 +1333,8 @@ void IrrDriver::renderSolidSecondPass()
         for (unsigned i = 0; i < ImmediateDrawList::getInstance()->size(); i++)
             ImmediateDrawList::getInstance()->at(i)->render();
 
-        std::vector<GLuint> DiffSpecSSAOTex = 
+        std::vector<GLuint> DiffSpecSSAOTex =
-            createVector<GLuint>(m_rtts->getRenderTarget(RTT_DIFFUSE), 
+            createVector<GLuint>(m_rtts->getRenderTarget(RTT_DIFFUSE),
                                  m_rtts->getRenderTarget(RTT_SPECULAR),
                                  m_rtts->getRenderTarget(RTT_HALF1_R));
 
@@ -1404,7 +1378,7 @@ void IrrDriver::renderSolidSecondPass()
                 }
             }
         }
-        else 
+        else
 #endif
         if (CVS->supportsIndirectInstancingRendering())
         {
@@ -1453,8 +1427,8 @@ static void renderInstancedMeshNormals()
     for (unsigned i = 0; i < meshes.size(); i++)
     {
         NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0));
-        glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, 
+        glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
-             (const void*)((SolidPassCmd::getInstance()->Offset[T::MaterialType] + i) 
+             (const void*)((SolidPassCmd::getInstance()->Offset[T::MaterialType] + i)
              * sizeof(DrawElementsIndirectCommand)));
     }
 }   // renderInstancedMeshNormals
@@ -1500,9 +1474,9 @@ void IrrDriver::renderNormalsVisualisation()
 }   // renderNormalsVisualisation
 
 // ----------------------------------------------------------------------------
-template<typename Shader, enum video::E_VERTEX_TYPE VertexType, int...List, 
+template<typename Shader, enum video::E_VERTEX_TYPE VertexType, int...List,
          typename... TupleType>
-void renderTransparenPass(const std::vector<RenderGeometry::TexUnit> &TexUnits, 
+void renderTransparenPass(const std::vector<RenderGeometry::TexUnit> &TexUnits,
                           std::vector<STK::Tuple<TupleType...> > *meshes)
 {
     Shader::getInstance()->use();
@@ -1560,9 +1534,9 @@ void IrrDriver::renderTransparent()
                              TexUnits(RenderGeometry::TexUnit(0, true)),
                               ListBlendTransparentFog::getInstance());
         glBlendFunc(GL_ONE, GL_ONE);
-        renderTransparenPass<Shaders::TransparentFogShader, 
+        renderTransparenPass<Shaders::TransparentFogShader,
                              video::EVT_STANDARD, 8, 7, 6, 5, 4, 3, 2, 1>(
-                             TexUnits(RenderGeometry::TexUnit(0, true)), 
+                             TexUnits(RenderGeometry::TexUnit(0, true)),
                                        ListAdditiveTransparentFog::getInstance());
     }
     else
@@ -1638,7 +1612,7 @@ void IrrDriver::renderTransparent()
         displaceTex = irr_driver->getTexture(FileManager::TEXTURE, "displace.png");
     for (unsigned i = 0; i < ListDisplacement::getInstance()->size(); i++)
     {
-        const GLMesh &mesh = 
+        const GLMesh &mesh =
             *(STK::tuple_get<0>(ListDisplacement::getInstance()->at(i)));
         if (!CVS->isARBBaseInstanceUsable())
             glBindVertexArray(mesh.vao);
@@ -1668,7 +1642,7 @@ void IrrDriver::renderTransparent()
     irr_driver->getFBO(FBO_COLORS).bind();
     glStencilFunc(GL_EQUAL, 1, 0xFF);
     m_post_processing->renderPassThrough(m_rtts->getRenderTarget(RTT_DISPLACE),
-                                         irr_driver->getFBO(FBO_COLORS).getWidth(), 
+                                         irr_driver->getFBO(FBO_COLORS).getWidth(),
                                          irr_driver->getFBO(FBO_COLORS).getHeight());
     glDisable(GL_STENCIL_TEST);
 
@@ -1749,12 +1723,12 @@ void renderInstancedShadow(unsigned cascade, Args ...args)
     {
         GLMesh *mesh = t[i];
 
-        TexExpander<typename T::InstancedShadowPassShader>::template 
+        TexExpander<typename T::InstancedShadowPassShader>::template
                                        ExpandTex(*mesh, T::ShadowTextures);
         T::InstancedShadowPassShader::getInstance()->setUniforms(cascade, args...);
         size_t tmp = ShadowPassCmd::getInstance()->Offset[cascade][T::MaterialType] + i;
         glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
-                               (const void*)((tmp) 
+                               (const void*)((tmp)
                                * sizeof(DrawElementsIndirectCommand)));
     }   // for i
 
@@ -1771,10 +1745,10 @@ static void multidrawShadow(unsigned i, Args ...args)
     if (ShadowPassCmd::getInstance()->Size[i][T::MaterialType])
     {
         T::InstancedShadowPassShader::getInstance()->setUniforms(i, args...);
-        glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, 
+        glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
-            (const void*)(ShadowPassCmd::getInstance()->Offset[i][T::MaterialType] 
+            (const void*)(ShadowPassCmd::getInstance()->Offset[i][T::MaterialType]
             * sizeof(DrawElementsIndirectCommand)),
-            (int)ShadowPassCmd::getInstance()->Size[i][T::MaterialType], 
+            (int)ShadowPassCmd::getInstance()->Size[i][T::MaterialType],
             sizeof(DrawElementsIndirectCommand));
     }
 #endif
@@ -1846,7 +1820,7 @@ void IrrDriver::renderShadows()
 
         if (CVS->isARBTextureViewUsable())
         {
-            const std::pair<float, float>* shadow_scales 
+            const std::pair<float, float>* shadow_scales
                 = getShadowMatrices()->getShadowScales();
 
             for (unsigned i = 0; i < 2; i++)
@@ -1872,7 +1846,7 @@ template<>
 struct rsm_custom_unroll_args<>
 {
     template<typename T, typename ...TupleTypes, typename ...Args>
-    static void exec(const core::matrix4 &rsm_matrix, 
+    static void exec(const core::matrix4 &rsm_matrix,
                       const STK::Tuple<TupleTypes...> &t, Args... args)
     {
         draw<T>(T::getInstance(), STK::tuple_get<0>(t), rsm_matrix, args...);
@@ -1887,7 +1861,7 @@ struct rsm_custom_unroll_args<N, List...>
     static void exec(const core::matrix4 &rsm_matrix,
                      const STK::Tuple<TupleTypes...> &t, Args... args)
     {
-        rsm_custom_unroll_args<List...>::template 
+        rsm_custom_unroll_args<List...>::template
             exec<T>(rsm_matrix, t, STK::tuple_get<N>(t), args...);
     }
 };   // rsm_custom_unroll_args
@@ -1946,7 +1920,7 @@ void multidrawRSM(Args...args)
     {
         T::InstancedRSMShader::getInstance()->setUniforms(args...);
         glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
-            (const void*)(RSMPassCmd::getInstance()->Offset[T::MaterialType] 
+            (const void*)(RSMPassCmd::getInstance()->Offset[T::MaterialType]
                * sizeof(DrawElementsIndirectCommand)),
             (int)RSMPassCmd::getInstance()->Size[T::MaterialType],
             sizeof(DrawElementsIndirectCommand));

src/graphics/render_lighting.cpp

@@ -66,21 +66,17 @@ public:
     PointLightShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "pointlight.vert",
-                            GL_FRAGMENT_SHADER, "utils/decodeNormal.frag",
-                            GL_FRAGMENT_SHADER, "utils/SpecularBRDF.frag",
-                            GL_FRAGMENT_SHADER, "utils/DiffuseBRDF.frag",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
                             GL_FRAGMENT_SHADER, "pointlight.frag");
 
         assignUniforms();
-        assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED, 
+        assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED,
                            1, "dtex", ST_NEAREST_FILTERED);
         glGenVertexArrays(1, &vao);
         glBindVertexArray(vao);
 
         glGenBuffers(1, &vbo);
         glBindBuffer(GL_ARRAY_BUFFER, vbo);
-        glBufferData(GL_ARRAY_BUFFER, 
+        glBufferData(GL_ARRAY_BUFFER,
                      LightBaseClass::MAXLIGHT * sizeof(LightBaseClass::PointLightInfo),
                      0, GL_DYNAMIC_DRAW);
 
@@ -90,7 +86,7 @@ public:
         GLuint attrib_Radius = glGetAttribLocation(m_program, "Radius");
 
         glEnableVertexAttribArray(attrib_Position);
-        glVertexAttribPointer(attrib_Position, 3, GL_FLOAT, GL_FALSE, 
+        glVertexAttribPointer(attrib_Position, 3, GL_FLOAT, GL_FALSE,
                               sizeof(LightBaseClass::PointLightInfo), 0);
         glEnableVertexAttribArray(attrib_Energy);
         glVertexAttribPointer(attrib_Energy, 1, GL_FLOAT, GL_FALSE,
@@ -101,7 +97,7 @@ public:
                               sizeof(LightBaseClass::PointLightInfo),
                               (GLvoid*)(4 * sizeof(float)));
         glEnableVertexAttribArray(attrib_Radius);
-        glVertexAttribPointer(attrib_Radius, 1, GL_FLOAT, GL_FALSE, 
+        glVertexAttribPointer(attrib_Radius, 1, GL_FLOAT, GL_FALSE,
                               sizeof(LightBaseClass::PointLightInfo),
                               (GLvoid*)(7 * sizeof(float)));
 
@@ -125,7 +121,6 @@ public:
     PointLightScatterShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "pointlight.vert",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
                             GL_FRAGMENT_SHADER, "pointlightscatter.frag");
 
         assignUniforms("density", "fogcol");
@@ -175,11 +170,6 @@ public:
     ShadowedSunLightShaderPCF()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/decodeNormal.frag",
-                            GL_FRAGMENT_SHADER, "utils/SpecularBRDF.frag",
-                            GL_FRAGMENT_SHADER, "utils/DiffuseBRDF.frag",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
-                            GL_FRAGMENT_SHADER, "utils/SunMRP.frag",
                             GL_FRAGMENT_SHADER, "sunlightshadow.frag");
 
         // Use 8 to circumvent a catalyst bug when binding sampler
@@ -197,7 +187,7 @@ public:
        drawFullScreenEffect(ShadowMatrices::m_shadow_split[1],
                             ShadowMatrices::m_shadow_split[2],
                             ShadowMatrices::m_shadow_split[3],
-                            ShadowMatrices::m_shadow_split[4], 
+                            ShadowMatrices::m_shadow_split[4],
                             float(UserConfigParams::m_shadows_resolution)   );
 
     }    // render
@@ -209,21 +199,16 @@ class ShadowedSunLightShaderESM : public TextureShader<ShadowedSunLightShaderESM
                                                        float>
 {
 public:
-    ShadowedSunLightShaderESM() 
+    ShadowedSunLightShaderESM()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/decodeNormal.frag",
-                            GL_FRAGMENT_SHADER, "utils/SpecularBRDF.frag",
-                            GL_FRAGMENT_SHADER, "utils/DiffuseBRDF.frag",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
-                            GL_FRAGMENT_SHADER, "utils/SunMRP.frag",
                             GL_FRAGMENT_SHADER, "sunlightshadowesm.frag");
 
         // Use 8 to circumvent a catalyst bug when binding sampler
         assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED,
                            1, "dtex", ST_NEAREST_FILTERED,
                            8, "shadowtex", ST_TRILINEAR_CLAMPED_ARRAY2D);
-            
+
         assignUniforms("split0", "split1", "split2", "splitmax");
     }   // ShadowedSunLightShaderESM
     // ------------------------------------------------------------------------
@@ -241,7 +226,7 @@ public:
 
 // ============================================================================
 class RadianceHintsConstructionShader
-    : public TextureShader<RadianceHintsConstructionShader, 3, core::matrix4, 
+    : public TextureShader<RadianceHintsConstructionShader, 3, core::matrix4,
                           core::matrix4, core::vector3df, video::SColorf>
 {
 public:
@@ -299,7 +284,6 @@ public:
     FogShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
-                            GL_FRAGMENT_SHADER, "utils/getPosFromUVDepth.frag",
                             GL_FRAGMENT_SHADER, "fog.frag");
         assignUniforms("density", "col");
         assignSamplerNames(0, "tex", ST_NEAREST_FILTERED);
@@ -325,7 +309,7 @@ static void renderPointLights(unsigned count)
     PointLightShader::getInstance()->use();
     glBindVertexArray(PointLightShader::getInstance()->vao);
     glBindBuffer(GL_ARRAY_BUFFER, PointLightShader::getInstance()->vbo);
-    glBufferSubData(GL_ARRAY_BUFFER, 0, 
+    glBufferSubData(GL_ARRAY_BUFFER, 0,
                      count * sizeof(LightBaseClass::PointLightInfo),
                      m_point_lights_info);
 
@@ -355,7 +339,7 @@ unsigned IrrDriver::updateLightsInfo(scene::ICameraSceneNode * const camnode,
             m_lights[i]->render();
             continue;
         }
-        const core::vector3df &lightpos = 
+        const core::vector3df &lightpos =
                                  (m_lights[i]->getAbsolutePosition() - campos);
         unsigned idx = (unsigned)(lightpos.getLength() / 10);
         if (idx > 14)
@@ -395,7 +379,7 @@ unsigned IrrDriver::updateLightsInfo(scene::ICameraSceneNode * const camnode,
                 m_point_lights_info[lightnum].posY = pos.Y;
                 m_point_lights_info[lightnum].posZ = pos.Z;
 
-                m_point_lights_info[lightnum].energy = 
+                m_point_lights_info[lightnum].energy =
                                               light_node->getEffectiveEnergy();
 
                 const core::vector3df &col = light_node->getColor();
@@ -463,7 +447,7 @@ void IrrDriver::renderLights(unsigned pointlightcount, bool hasShadow)
             for (unsigned i = 0; i < 32; i++)
             {
                 NVWorkaroundRadianceHintsConstructionShader::getInstance()
-                    ->setUniforms(getShadowMatrices()->getRSMMatrix(), 
+                    ->setUniforms(getShadowMatrices()->getRSMMatrix(),
                                   getShadowMatrices()->getRHMatrix(),
                                   getShadowMatrices()->getRHExtend(), i,
                                   irr_driver->getSunColor());
@@ -481,7 +465,7 @@ void IrrDriver::renderLights(unsigned pointlightcount, bool hasShadow)
             );
             RadianceHintsConstructionShader::getInstance()
                 ->setUniforms(getShadowMatrices()->getRSMMatrix(),
-                              getShadowMatrices()->getRHMatrix(), 
+                              getShadowMatrices()->getRHMatrix(),
                               getShadowMatrices()->getRHExtend(),
                               irr_driver->getSunColor());
             glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 32);
@@ -508,10 +492,10 @@ void IrrDriver::renderLights(unsigned pointlightcount, bool hasShadow)
         {
             m_post_processing->renderEnvMap(m_skybox->getSpecularProbe());
         }
-        else 
+        else
         {
             m_post_processing->renderEnvMap(0);
-        }           
+        }
     }
 
     // Render sunlight if and only if track supports shadow
@@ -553,9 +537,9 @@ void IrrDriver::renderSSAO()
     m_post_processing->renderSSAO();
     // Blur it to reduce noise.
     FrameBuffer::Blit(m_rtts->getFBO(FBO_SSAO),
-                      m_rtts->getFBO(FBO_HALF1_R), 
+                      m_rtts->getFBO(FBO_HALF1_R),
                       GL_COLOR_BUFFER_BIT, GL_LINEAR);
-    m_post_processing->renderGaussian17TapBlur(irr_driver->getFBO(FBO_HALF1_R), 
+    m_post_processing->renderGaussian17TapBlur(irr_driver->getFBO(FBO_HALF1_R),
                                                irr_driver->getFBO(FBO_HALF2_R));
 
 }   // renderSSAO

src/graphics/shadow_matrices.cpp

@@ -40,20 +40,19 @@
 float ShadowMatrices:: m_shadow_split[5] = { 1., 5., 20., 50., 150 };
 
 // ============================================================================
-class LightspaceBoundingBoxShader 
+class LightspaceBoundingBoxShader
     : public TextureShader<LightspaceBoundingBoxShader, 1,
                            core::matrix4, float, float, float, float>
 {
 public:
-    LightspaceBoundingBoxShader() 
+    LightspaceBoundingBoxShader()
     {
 #if !defined(ANDROID) && !defined(USE_GLES2)
-        loadProgram(OBJECT, GL_COMPUTE_SHADER, "Lightspaceboundingbox.comp",
+        loadProgram(OBJECT, GL_COMPUTE_SHADER, "Lightspaceboundingbox.comp");
-                            GL_COMPUTE_SHADER, "utils/getPosFromUVDepth.frag");
         assignSamplerNames(0, "depth", ST_NEAREST_FILTERED);
         assignUniforms("SunCamMatrix", "split0", "split1", "split2", "splitmax");
-        GLuint block_idx = 
+        GLuint block_idx =
-            glGetProgramResourceIndex(m_program, GL_SHADER_STORAGE_BLOCK, 
+            glGetProgramResourceIndex(m_program, GL_SHADER_STORAGE_BLOCK,
                                       "BoundingBoxes");
         glShaderStorageBlockBinding(m_program, block_idx, 2);
 #endif
@@ -61,7 +60,7 @@ public:
 };   // LightspaceBoundingBoxShader
 
 // ============================================================================
-class ShadowMatricesGenerationShader 
+class ShadowMatricesGenerationShader
     : public Shader <ShadowMatricesGenerationShader, core::matrix4>
 {
 public:
@@ -70,11 +69,11 @@ public:
 #if !defined(ANDROID) && !defined(USE_GLES2)
         loadProgram(OBJECT,  GL_COMPUTE_SHADER, "shadowmatrixgeneration.comp");
         assignUniforms("SunCamMatrix");
-        GLuint block_idx = 
+        GLuint block_idx =
-            glGetProgramResourceIndex(m_program, 
+            glGetProgramResourceIndex(m_program,
                                       GL_SHADER_STORAGE_BLOCK, "BoundingBoxes");
         glShaderStorageBlockBinding(m_program, block_idx, 2);
-        block_idx = 
+        block_idx =
             glGetProgramResourceIndex(m_program, GL_SHADER_STORAGE_BLOCK,
                                       "NewMatrixData");
         glShaderStorageBlockBinding(m_program, block_idx, 1);
@@ -161,7 +160,7 @@ static std::vector<vector3df> getFrustrumVertex(const scene::SViewFrustum &frust
 
 // ----------------------------------------------------------------------------
 /** Given a matrix transform and a set of points returns an orthogonal
- *  projection matrix that maps coordinates of transformed points between -1 
+ *  projection matrix that maps coordinates of transformed points between -1
  *  and 1.
  *  \param transform a transform matrix.
  *  \param pointsInside a vector of point in 3d space.
@@ -210,14 +209,14 @@ core::matrix4 ShadowMatrices::getTighestFitOrthoProj(const core::matrix4 &transf
 
 // ----------------------------------------------------------------------------
 /** Update shadowSplit values and make Cascade Bounding Box pointer valid.
- *  The function aunches two compute kernel that generates an histogram of the 
+ *  The function aunches two compute kernel that generates an histogram of the
  *  depth buffer value (between 0 and 250 with increment of 0.25) and get an
  *  axis aligned bounding box (from SunCamMatrix view) containing all depth
- *  buffer value. It also retrieves the result from the previous computations 
+ *  buffer value. It also retrieves the result from the previous computations
  *  (in a Round Robin fashion) and update CBB pointer.
  *  \param width of the depth buffer
  *  \param height of the depth buffer
- *  TODO : The depth histogram part is commented out, needs to tweak it when 
+ *  TODO : The depth histogram part is commented out, needs to tweak it when
  *         I have some motivation
  */
 void ShadowMatrices::updateSplitAndLightcoordRangeFromComputeShaders(unsigned int width,
@@ -403,7 +402,7 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
             m_shadow_cam_nodes[i]->render();
 
             m_sun_ortho_matrices.push_back(
-                  irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION) 
+                  irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION)
                 * irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW)       );
         }
 
@@ -425,14 +424,14 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
                 m_sun_cam->setProjectionMatrix(tmp_matrix, true);
                 m_sun_cam->render();
             }
-            m_rsm_matrix = irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION) 
+            m_rsm_matrix = irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION)
                          * irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW);
             m_rsm_matrix_initialized = true;
             m_rsm_map_available = false;
         }
         m_rh_extend = core::vector3df(128, 64, 128);
         core::vector3df campos = camnode->getAbsolutePosition();
-        core::vector3df translation(8 * floor(campos.X / 8), 
+        core::vector3df translation(8 * floor(campos.X / 8),
                                     8 * floor(campos.Y / 8),
                                     8 * floor(campos.Z / 8));
         m_rh_matrix.setTranslation(translation);
@@ -453,12 +452,12 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
 
     tmp[144] = float(width);
     tmp[145] = float(height);
-    glBindBuffer(GL_UNIFORM_BUFFER, 
+    glBindBuffer(GL_UNIFORM_BUFFER,
                  SharedGPUObjects::getViewProjectionMatricesUBO());
     if (CVS->isSDSMEnabled())
     {
         glBufferSubData(GL_UNIFORM_BUFFER, 0, (16 * 5) * sizeof(float), tmp);
-        glBufferSubData(GL_UNIFORM_BUFFER, (16 * 9) * sizeof(float), 
+        glBufferSubData(GL_UNIFORM_BUFFER, (16 * 9) * sizeof(float),
                         2 * sizeof(float), &tmp[144]);
     }
     else