diff --git a/Levels/ObjectSetups/Compositions.xml b/Levels/ObjectSetups/Compositions.xml
index 7792f76..5bedaf1 100644
--- a/Levels/ObjectSetups/Compositions.xml
+++ b/Levels/ObjectSetups/Compositions.xml
@@ -69,7 +69,7 @@
     </object>
     <light>
         <xOffset>0.0</xOffset>
-        <yOffset>3</yOffset>
+        <yOffset>2</yOffset>
         <zOffset>0.0</zOffset>
         <rColour>1.0</rColour>
         <gColour>1.0</gColour>
diff --git a/Shader/depth.fsh b/Shader/depth.fsh
index b236c6a..4e98194 100644
--- a/Shader/depth.fsh
+++ b/Shader/depth.fsh
@@ -1,7 +1,7 @@
 #version 150
 
-out float fragmentDepth;
+out float gl_FragDepth;
 
 void main() {
-    fragmentDepth = gl_FragCoord.z;
+    gl_FragDepth = gl_FragCoord.z;
 }
diff --git a/Shader/depth_cube.fsh b/Shader/depth_cube.fsh
new file mode 100644
index 0000000..d7beeb7
--- /dev/null
+++ b/Shader/depth_cube.fsh
@@ -0,0 +1,16 @@
+#version 150
+
+in vec4 fragPosition;
+
+uniform float farPlane;
+
+out float gl_FragDepth;
+
+void main() {
+    float nearPlane = 0.1;
+    float A = -(farPlane+nearPlane)/(farPlane-nearPlane);
+    float B = -2*(farPlane*nearPlane)/(farPlane - nearPlane);
+    float value = 0.5*(-A*length(fragPosition) + B)/length(fragPosition) + 0.5;
+    gl_FragDepth = value;
+    //gl_FragDepth = length(fragPosition)/farPlane;
+}
diff --git a/Shader/depth_cube.vsh b/Shader/depth_cube.vsh
new file mode 100644
index 0000000..2618bfa
--- /dev/null
+++ b/Shader/depth_cube.vsh
@@ -0,0 +1,15 @@
+#version 150
+
+in vec3 aPosition;
+in vec3 aNormal;
+in vec3 aTexcoord;
+
+uniform mat4 modelViewProjectionMatrix;
+uniform mat4 modelViewMatrix;
+
+out vec4 fragPosition;
+
+void main() {
+    fragPosition = modelViewMatrix * vec4(aPosition, 1.0);
+    gl_Position = modelViewProjectionMatrix * vec4(aPosition, 1.0);
+}
diff --git a/Shader/phong.fsh b/Shader/phong.fsh
index 447b1fe..e9a7f13 100644
--- a/Shader/phong.fsh
+++ b/Shader/phong.fsh
@@ -9,7 +9,16 @@ out vec4 oColor;
 
 uniform sampler2D uTexture;
 uniform sampler2DShadow shadowMap;
-uniform samplerCubeShadow shadowMap_cube;
+uniform samplerCubeShadow shadowMap_cube0;
+uniform samplerCubeShadow shadowMap_cube1;
+uniform samplerCubeShadow shadowMap_cube2;
+uniform samplerCubeShadow shadowMap_cube3;
+uniform samplerCubeShadow shadowMap_cube4;
+uniform samplerCubeShadow shadowMap_cube5;
+uniform samplerCubeShadow shadowMap_cube6;
+uniform samplerCubeShadow shadowMap_cube7;
+uniform samplerCubeShadow shadowMap_cube8;
+uniform samplerCubeShadow shadowMap_cube9;
 uniform vec3 ambientColor;
 uniform float ambientFactor;
 uniform float diffuseFactor;
@@ -70,9 +79,10 @@ float samplePointShadow(samplerCubeShadow shadowMap, vec3 lightDirection) {
     float A = -(farPlane+nearPlane)/(farPlane-nearPlane);
     float B = -2*(farPlane*nearPlane)/(farPlane - nearPlane);
     float compValue = 0.5*(-A*length(lightDirection) + B)/length(lightDirection) + 0.5;
-    float bias = 0.005;
-    vec3 vector = vec3(-lightDirection.x, -lightDirection.y, lightDirection.z);
-    return texture(shadowMap, vec4(vector , compValue - bias));
+    float bias = 0.001*tan(acos(clamp(dot(vNormal, -directionalLightVector), 0.0, 1.0)));
+    bias = clamp(bias, 0.0, 0.01);
+    //return texture(shadowMap, vec4(lightDirection , length(lightDirection)/farPlane - bias));
+    return texture(shadowMap, vec4(lightDirection , compValue - bias));
 }
 
 float distanceToBorder(vec2 vector) {
@@ -91,11 +101,13 @@ void main()
     // direction lighting
     if(length(directionalLightVector)>0.0f) {
         vec3 directionalVector = normalize(directionalLightVector);
+        float directionalVisibility = sampleDirectionalShadow(shadowMap, shadowCoord);
         diffuseColor += clamp(dot(normalize(vNormal), directionalVector)
-        *diffuseFactor*directionalIntensity*directionalColor, 0.0, 1.0);
+        *diffuseFactor*directionalIntensity*directionalColor, 0.0, 1.0)*directionalVisibility;
         vec3 cameraVector = normalize(camera - vec3(fragPosition));
-        specularColor += clamp(pow((dot((cameraVector+directionalVector),normalize(vNormal))/(length(cameraVector+directionalVector)*length(normalize(vNormal)))),shininess), 0.0, 1.0)
-        *specularFactor*directionalIntensity*directionalColor;
+        specularColor += clamp(pow((dot((cameraVector+directionalVector),normalize(vNormal))/
+        (length(cameraVector+directionalVector)*length(normalize(vNormal)))),shininess), 0.0, 1.0)
+        *specularFactor*directionalIntensity*directionalColor*directionalVisibility;
     }
 
     // point lights
@@ -103,24 +115,58 @@ void main()
     for(int i = 0; i<lightCount; i++) {
         vec3 lightDirection = vec3(fragPosition) - lightSources[i];
         float distance = length(lightDirection);
+        float pointVisibility = 0.0f;
         // only take lights into account with meaningful contribution
-        if (distance > 0.001f) {
+        if (distance < farPlane) {
+            if (i == 0) {
+                pointVisibility = samplePointShadow(shadowMap_cube0, lightDirection);
+            }
+            if (i == 1) {
+                pointVisibility = samplePointShadow(shadowMap_cube1, lightDirection);
+            }
+
+            if (i == 2) {
+                pointVisibility = samplePointShadow(shadowMap_cube2, lightDirection);
+            }
+
+            if (i == 3) {
+                pointVisibility = samplePointShadow(shadowMap_cube3, lightDirection);
+            }
+
+            if (i == 4) {
+                pointVisibility = samplePointShadow(shadowMap_cube4, lightDirection);
+            }
+
+            if (i == 5) {
+                pointVisibility = samplePointShadow(shadowMap_cube5, lightDirection);
+            }
+
+            if (i == 6) {
+                pointVisibility = samplePointShadow(shadowMap_cube6, lightDirection);
+            }
+
+            if (i == 7) {
+                pointVisibility = samplePointShadow(shadowMap_cube7, lightDirection);
+            }
+
+            if (i == 8) {
+                pointVisibility = samplePointShadow(shadowMap_cube8, lightDirection);
+            }
+
+            if (i == 9) {
+                pointVisibility = samplePointShadow(shadowMap_cube9, lightDirection);
+            }
             vec3 lightVector = normalize(lightSources[i]-vec3(fragPosition));
             float intensity = clamp(exp(-(1/lightIntensities[i])*distance), 0.0, 1.0);
             diffuseColor += clamp(dot(normalize(vNormal), lightVector)
-            *diffuseFactor*intensity*lightColors[i], 0.0, 1.0);
+            *diffuseFactor*intensity*lightColors[i], 0.0, 1.0)*pointVisibility;
             vec3 cameraVector = normalize(camera - vec3(fragPosition));
-            specularColor += clamp(pow((dot((cameraVector+lightVector),normalize(vNormal))/(length(cameraVector+lightVector)*length(normalize(vNormal)))),shininess), 0.0, 1.0)
-            *specularFactor*intensity*lightColors[i];
-            visibility = samplePointShadow(shadowMap_cube, lightDirection);
+            specularColor += clamp(pow((dot((cameraVector+lightVector),normalize(vNormal))/
+            (length(cameraVector+lightVector)*length(normalize(vNormal)))),shininess), 0.0, 1.0)
+            *specularFactor*intensity*lightColors[i]*pointVisibility;
         }
     }
 
-    // shadows 
-    visibility *= sampleDirectionalShadow(shadowMap, shadowCoord);
-
-    specularColor *= visibility;
-    diffuseColor  *= visibility;
 
     vec3 finalColor = specularColor + diffuseColor + ambientColor;
     float distanceCameraCenter = distance(cameraCenter, vec3(fragPosition));
diff --git a/application.cc b/application.cc
index b16e9c0..a3290f5 100644
--- a/application.cc
+++ b/application.cc
@@ -5,7 +5,7 @@ Application::Application() {
     Loader loader = Loader();
     //load the config.xml
     loader.loadConfig(this);
-    graphics = Graphics(glm::uvec2(windowWidth, windowHeight), 0.1f, farPlane, shadowCubeSize);
+    graphics = Graphics(glm::uvec2(windowWidth, windowHeight), 0.1f, farPlane, shadowCubeSize, maxShadowRenderCount);
 }
 
 void Application::init()
@@ -122,3 +122,7 @@ void Application::setHeightmapPath(std::string heightmapPath) {
 void Application::setLevelXmlPath(std::string levelXmlPath) {
     this->levelXmlPath = levelXmlPath;
 }
+
+void Application::setMaxShadowRenderCount(int count) {
+    this->maxShadowRenderCount = count;
+}
diff --git a/application.hh b/application.hh
index 0a58d84..169a664 100644
--- a/application.hh
+++ b/application.hh
@@ -22,6 +22,7 @@ class Application {
         void setWindowHeight(int windowHeight);
         void setShadowCubeSize(int shadowCubeSize);
         void setFarPlane(float farPlane);
+        void setMaxShadowRenderCount(int count);
         void setCompositionsPath(std::string compositionsPath);
         void setShaderPath(std::string shaderPath);
         void setGeometryPath(std::string geometryPath);
@@ -38,6 +39,7 @@ class Application {
         int windowWidth;
         int windowHeight;
         int shadowCubeSize;
+        int maxShadowRenderCount;
         float farPlane;
         std::string compositionsPath;
         std::string shaderPath;
diff --git a/data/config.xml b/data/config.xml
index fd1c30f..fc95c9d 100644
--- a/data/config.xml
+++ b/data/config.xml
@@ -7,6 +7,8 @@
 
 <farPlane>150.0</farPlane>
 
+<maxShadowRenderCount>10</maxShadowRenderCount>
+
 <compositionsPath>../Levels/ObjectSetups/Compositions.xml</compositionsPath>
 
 <shaderPath>Shader/</shaderPath>
diff --git a/graphics.cc b/graphics.cc
index 29f7434..809f67f 100644
--- a/graphics.cc
+++ b/graphics.cc
@@ -1,7 +1,9 @@
 #include "graphics.hh"
+#include "lodepng.h"
 
 #include <iomanip>
 #include <sstream>
+#include <functional>
 
 #include <ACGL/OpenGL/Creator/ShaderProgramCreator.hh>
 
@@ -9,11 +11,14 @@ using namespace ACGL::OpenGL;
 
 const double lightUpdateDelay = 0.5f;
 
-Graphics::Graphics(glm::uvec2 windowSize, float nearPlane, float farPlane, int cube_size) {
+Graphics::Graphics(glm::uvec2 windowSize, float nearPlane, 
+    float farPlane, int cube_size,
+    unsigned int maxShadowRenderCount) {
     this->windowSize = windowSize;
     this->nearPlane = nearPlane;
     this->farPlane = farPlane;
     this->cube_size = cube_size;
+    this->maxShadowRenderCount = maxShadowRenderCount;
 }
 
 Graphics::Graphics() {
@@ -40,8 +45,11 @@ void Graphics::init(Level* level) {
     
     depthShader = ShaderProgramCreator("depth")
         .attributeLocations(vao->getAttributeLocations()).create();
-    
-    depthTexture = SharedTexture2D( new Texture2D(windowSize, GL_DEPTH_COMPONENT16));
+
+    depthCubeShader = ShaderProgramCreator("depth_cube")
+        .attributeLocations(vao->getAttributeLocations()).create();
+
+    depthTexture = SharedTexture2D( new Texture2D(windowSize, GL_DEPTH_COMPONENT24));
     depthTexture->setMinFilter(GL_NEAREST);
     depthTexture->setMagFilter(GL_NEAREST);
     depthTexture->setWrapS(GL_CLAMP_TO_EDGE);
@@ -51,12 +59,19 @@ void Graphics::init(Level* level) {
     framebuffer = SharedFrameBufferObject(new FrameBufferObject());
     framebuffer->setDepthTexture(depthTexture);
     framebuffer->validate();
-    
-    /*depth_cubeMaps = std::vector<ACGL::OpenGL::SharedTextureCubeMap>(level->getLights()->size());
-    for (unsigned int i = 0; i<depth_cubeMaps.size(); i++) {*/
-    depth_cubeMaps = std::vector<ACGL::OpenGL::SharedTextureCubeMap>(std::min(int(level->getLights()->size()), 1));
-    for (unsigned int i = 0; i<1 && i<depth_cubeMaps.size(); i++) {
-        depth_cubeMaps.at(i) = SharedTextureCubeMap(new TextureCubeMap(glm::vec2(cube_size, cube_size), GL_DEPTH_COMPONENT16));
+
+    glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &number_of_texture_units);
+    printf("Your graphics card supports %d texture units.\n", number_of_texture_units);
+    // Exit if we need more texture units
+    if (number_of_texture_units < 12) {
+        printf("You need at least 12 texture units to run this application. Exiting\n");
+        exit(-1);
+    }
+
+    // always generate and bind 32 cube maps, because otherwise the shader won't work
+    depth_cubeMaps = std::vector<ACGL::OpenGL::SharedTextureCubeMap>(10);
+    for (unsigned int i = 0; i<depth_cubeMaps.size(); i++) {
+        depth_cubeMaps.at(i) = SharedTextureCubeMap(new TextureCubeMap(glm::vec2(cube_size, cube_size), GL_DEPTH_COMPONENT24));
         depth_cubeMaps.at(i)->setMinFilter(GL_NEAREST);
         depth_cubeMaps.at(i)->setMagFilter(GL_NEAREST);
         depth_cubeMaps.at(i)->setWrapS(GL_CLAMP_TO_EDGE);
@@ -65,13 +80,18 @@ void Graphics::init(Level* level) {
     }
     
     framebuffer_cube = SharedFrameBufferObject(new FrameBufferObject());
-    
-    depthTexture_cube = SharedTexture2D( new Texture2D(windowSize, GL_DEPTH_COMPONENT16));
-    depthTexture_cube->setMinFilter(GL_NEAREST);
-    depthTexture_cube->setMagFilter(GL_NEAREST);
-    depthTexture_cube->setWrapS(GL_CLAMP_TO_EDGE);
-    depthTexture_cube->setWrapT(GL_CLAMP_TO_EDGE);
-    depthTexture_cube->setCompareMode(GL_COMPARE_REF_TO_TEXTURE);
+
+    lightingShader->use();
+
+    lightingShader->setTexture("shadowMap", depthTexture, 1);
+
+    if (level->getLights()->size() > 0) {
+        for(unsigned int i = 0; i<depth_cubeMaps.size(); i++){
+            // start with texture unit 2 because the first two are used by the texture and the directional shadow map
+            lightingShader->setTexture("shadowMap_cube" + std::to_string(i), depth_cubeMaps.at(i), i+2);
+        }
+    }
+    updateClosestLights();
 }
 
 glm::uvec2 Graphics::getWindowSize() {
@@ -81,29 +101,35 @@ glm::uvec2 Graphics::getWindowSize() {
 void Graphics::render(double time)
 {
     // At first render shadows
-    depthShader->use();
+    depthCubeShader->use();
+    depthCubeShader->setUniform("farPlane", farPlane);
     // render depth textures for point lights
     glViewport(0, 0, cube_size, cube_size);
     glm::mat4 depthProjectionMatrix_pointlights = glm::perspective(1.571f, (float)cube_size/(float)cube_size, 0.1f,  farPlane);
-    glm::vec3 looking_directions[6] = {glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f),
+    glm::vec3 looking_directions[6] = {glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f),
         glm::vec3(0.0f, -1.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.0f, 0.0f, -1.0f)};
-    
+    glm::vec3 upvectors[6] = {glm::vec3(0.0f, -1.0f, 0.0f),glm::vec3(0.0f, -1.0f, 0.0f),glm::vec3(0.0f, 0.0f, -1.0f),
+        glm::vec3(0.0f, 0.0f, -1.0f),glm::vec3(0.0f, -1.0f, 0.0f),glm::vec3(0.0f, -1.0f, 0.0f)};
+
     framebuffer_cube->bind();
-    //for (unsigned int i_pointlight = 0; i_pointlight<level->getLights()->size(); i_pointlight++) {
-    for (unsigned int i_pointlight = 0; i_pointlight<1 && i_pointlight<level->getLights()->size(); i_pointlight++) {
+    for (unsigned int i_pointlight = 0; i_pointlight<closestLights->size() && i_pointlight < maxShadowRenderCount; i_pointlight++) {
         // render each side of the cube
         for (int i_face = 0; i_face<6; i_face++) {
             glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i_face, depth_cubeMaps.at(i_pointlight)->getObjectName(), 0);
             glClear(GL_DEPTH_BUFFER_BIT);
-            glm::mat4 depthViewProjectionMatrix_face = depthProjectionMatrix_pointlights * glm::lookAt(level->getLights()->at(i_pointlight).getPosition(),
-                level->getLights()->at(i_pointlight).getPosition() + looking_directions[i_face], glm::vec3(0.0f, 1.0f, 0.0f));
-            level->render(depthShader, false, &depthViewProjectionMatrix_face);
+            glm::mat4 viewMatrix = glm::lookAt(closestLights->at(i_pointlight).getPosition(),
+                closestLights->at(i_pointlight).getPosition() + looking_directions[i_face], upvectors[i_face]);
+            glm::mat4 depthViewProjectionMatrix_face = depthProjectionMatrix_pointlights * viewMatrix;
+            std::vector<glm::mat4> viewMatrixVector = std::vector<glm::mat4>();
+            viewMatrixVector.push_back(viewMatrix);
+            level->render(depthCubeShader, false, &depthViewProjectionMatrix_face, &viewMatrixVector);
             if (!framebuffer_cube->isFrameBufferObjectComplete()) {
                 printf("Framebuffer incomplete, unknown error occured during shadow generation!\n");
             }
         }
     }
     // render depth texture for sun
+    depthShader->use();
     glViewport(0, 0, windowSize.x, windowSize.y);
     
     // far pass
@@ -122,19 +148,16 @@ void Graphics::render(double time)
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     
     lightingShader->use();
-    
-    if (level->getLights()->size() > 0) {
-        lightingShader->setTexture("shadowMap_cube", depth_cubeMaps.at(0), 4);
-    }
-    
+
     //set lighting parameters
     
     // TODO look into doing this less often, offload to another thread?
     // TODO figure out how to deal with bigger numbers of lights. load the nearest on demand?
+
     double nextUpdate = lastUpdate + lightUpdateDelay;
     if (time >= nextUpdate)
     {
-        updateLights();
+        updateShaderLights();
         lastUpdate = time;
     }
     
@@ -146,9 +169,6 @@ void Graphics::render(double time)
     0.5, 0.5, 0.5, 1.0
     );
     glm::mat4 depthBiasVP = biasMatrix*depthViewProjectionMatrix;
-    
-    lightingShader->setTexture("shadowMap", depthTexture, 1);
-    
     lightingShader->setUniform("farPlane", farPlane);
     
     // set fog Parameters
@@ -169,28 +189,54 @@ void Graphics::render(double time)
     level->render(lightingShader, true, &lightingViewProjectionMatrix, &shadowVPs);
 }
 
-void Graphics::updateLights() {
-    if (level->getLights()->size() > 0) {
-        lightingShader->setUniform("lightCount", (int) level->getLights()->size());
-        
+bool Graphics::compareLightDistances(Light a, Light b) {
+    if (glm::distance(this->level->getCameraCenter()->getPosition(), a.getPosition()) < 
+            glm::distance(this->level->getCameraCenter()->getPosition(), b.getPosition())) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+void Graphics::updateClosestLights() {
+    if (level->getLights()->size() <= 32) {
+        this->closestLights = level->getLights();
+    }
+    else {
+        closestLightsVector = std::vector<Light>(*level->getLights());
+        std::sort(closestLightsVector.begin(),
+            closestLightsVector.end(),
+            [this](Light a, Light b) {return compareLightDistances(a, b); });
+        closestLightsVector = std::vector<Light>(&closestLightsVector[0],
+                &closestLightsVector[31]);
+        closestLights = &closestLightsVector;
+    }
+}
+
+void Graphics::updateShaderLights() {
+    updateClosestLights();
+    if (closestLights->size() > 0) {
+        lightingShader->setUniform("lightCount", (int) closestLights->size());
+
         // Build light position array
-        glm::vec3 lightSources[level->getLights()->size()];
-        for(unsigned int i = 0; i<level->getLights()->size(); i++) {
-            lightSources[i] = level->getLights()->at(i).getPosition();
+        glm::vec3 lightSources[closestLights->size()];
+        for(unsigned int i = 0; i<closestLights->size(); i++) {
+            lightSources[i] = closestLights->at(i).getPosition();
         }
         glUniform3fv(lightingShader->getUniformLocation("lightSources"),
             sizeof(lightSources),  (GLfloat*) lightSources);
         // Build light colour array
-        glm::vec3 lightColours[level->getLights()->size()];
-        for(unsigned int i = 0; i<level->getLights()->size(); i++) {
-            lightColours[i] = level->getLights()->at(i).getColour();
+        glm::vec3 lightColours[closestLights->size()];
+        for(unsigned int i = 0; i<closestLights->size(); i++) {
+            lightColours[i] = closestLights->at(i).getColour();
         }
         glUniform3fv(lightingShader->getUniformLocation("lightColors"),
             sizeof(lightColours),  (GLfloat*) lightColours);
         // Build light attenuation array
-        float lightIntensities[level->getLights()->size()];
-        for(unsigned int i = 0; i<level->getLights()->size(); i++) {
-            lightIntensities[i] = level->getLights()->at(i).getIntensity();
+        float lightIntensities[closestLights->size()];
+        for(unsigned int i = 0; i<closestLights->size(); i++) {
+            lightIntensities[i] = closestLights->at(i).getIntensity();
         }
         glUniform1fv(lightingShader->getUniformLocation("lightIntensities"),
             sizeof(lightIntensities),  (GLfloat*) lightIntensities);
@@ -223,3 +269,25 @@ glm::mat4 Graphics::buildViewMatrix(Level* level) {
 float Graphics::getFarPlane() {
     return farPlane;
 }
+
+void Graphics::saveDepthBufferToDisk(int face, std::string filename) {
+    printf("Starting saving of depth buffer...\n");
+    float *depthbuffer = new float[1024*1024];
+    std::vector<unsigned char> image (1024 * 1024 * 4);
+
+    glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, GL_DEPTH_COMPONENT, GL_FLOAT, depthbuffer);
+    for (unsigned int i = 0; i<1024*1024; i++) {
+        image[i * 4 + 0] = depthbuffer[i] * 255;
+        image[i * 4 + 1] = depthbuffer[i] * 255;
+        image[i * 4 + 2] = depthbuffer[i] * 255;
+        image[i * 4 + 3] = 255;
+    }
+    unsigned error = lodepng::encode(filename.c_str(), image, 1024, 1024);
+    if (error) {
+        std::cout << "Encoder error " << error << ": " << lodepng_error_text(error) << std::endl;
+    }
+    else {
+        printf("Saving complete!\n");
+    }
+    delete [] depthbuffer;
+}
diff --git a/graphics.hh b/graphics.hh
index 96259cd..1876899 100644
--- a/graphics.hh
+++ b/graphics.hh
@@ -10,7 +10,7 @@
 
 class Graphics {
     public:
-        Graphics(glm::uvec2 windowSize, float nearPlane, float farPlane, int cube_size);
+        Graphics(glm::uvec2 windowSize, float nearPlane, float farPlane, int cube_size, unsigned int maxShadowRenderCount);
         Graphics();
         void init(Level* level);
         void render(double time);
@@ -19,20 +19,28 @@ class Graphics {
         void resize(glm::uvec2 windowSize);
         float getFarPlane();
     private:
-        void updateLights();
+        void updateShaderLights();
+        void updateClosestLights();
+        bool compareLightDistances(Light a, Light b);
+        void saveDepthBufferToDisk(int face, std::string);
         double lastUpdate;
         glm::uvec2 windowSize;
         float nearPlane;
         float farPlane;
+        // pointer to either use the vector from the level or from here
+        std::vector<Light>* closestLights;
+        std::vector<Light> closestLightsVector; // contains the 32 closest lights
         ACGL::OpenGL::SharedShaderProgram lightingShader;
+        ACGL::OpenGL::SharedShaderProgram depthCubeShader;
         ACGL::OpenGL::SharedShaderProgram depthShader;
         ACGL::OpenGL::SharedTexture2D depthTexture;
         ACGL::OpenGL::SharedFrameBufferObject framebuffer;
         std::vector<ACGL::OpenGL::SharedTextureCubeMap> depth_cubeMaps;
         ACGL::OpenGL::SharedFrameBufferObject framebuffer_cube;
-        ACGL::OpenGL::SharedTexture2D depthTexture_cube;
         int cube_size;
+        unsigned int maxShadowRenderCount;
         Level* level;
+        int number_of_texture_units = 0;
 };
 
 #endif
diff --git a/loader.cc b/loader.cc
index 2c49802..a65dbc8 100644
--- a/loader.cc
+++ b/loader.cc
@@ -5,7 +5,7 @@ Loader::Loader() {
 }
 
 void Loader::loadConfig(Application* application) {
-    int windowWidth, windowHeight, shadowCubeSize;
+    int windowWidth, windowHeight, shadowCubeSize, maxShadowRenderCount;
     float farPlane;
     std::string compositionsPath, shaderPath, geometryPath, texturePath, scriptPath, heightmapPath, levelXmlPath;
     XMLDocument* config = new XMLDocument();
@@ -20,6 +20,7 @@ void Loader::loadConfig(Application* application) {
     errorCheck(resolution->FirstChildElement("height")->QueryIntText(&windowHeight));
     errorCheck(config->FirstChildElement("shadowCubeSize")->QueryIntText(&shadowCubeSize));
     errorCheck(config->FirstChildElement("farPlane")->QueryFloatText(&farPlane));
+    errorCheck(config->FirstChildElement("maxShadowRenderCount")->QueryIntText(&maxShadowRenderCount));
     
     const char* charCompositionsPath = config->FirstChildElement("compositionsPath")->GetText();
     if(charCompositionsPath == NULL){
@@ -74,6 +75,7 @@ void Loader::loadConfig(Application* application) {
     application->setWindowHeight(windowHeight);
     application->setShadowCubeSize(shadowCubeSize);
     application->setFarPlane(farPlane);
+    application->setMaxShadowRenderCount(maxShadowRenderCount);
     application->setCompositionsPath(compositionsPath);
     application->setShaderPath(shaderPath);
     application->setGeometryPath(geometryPath);
diff --git a/object.cc b/object.cc
index 70acd47..3419786 100644
--- a/object.cc
+++ b/object.cc
@@ -14,7 +14,7 @@ Object::~Object() {
 }
 
 void Object::render(ACGL::OpenGL::SharedShaderProgram shader, bool lightingPass,
-    glm::mat4* viewProjectionMatrix, std::vector<glm::mat4>* shadowVPs) {
+    glm::mat4* viewProjectionMatrix, std::vector<glm::mat4>* additionalMatrices) {
     if (!renderable) {
         return;
     }
@@ -27,15 +27,20 @@ void Object::render(ACGL::OpenGL::SharedShaderProgram shader, bool lightingPass,
         shader->setUniform("shininess", material.getShininess());
         shader->setTexture("uTexture", material.getReference(), 0);
         // set model matrix
-        shader->setUniform( "modelMatrix", modelMatrix);
+        shader->setUniform("modelMatrix", modelMatrix);
         // set shadowMVPs
         glm::mat4 shadowMVPs[5];
-        for(unsigned int i = 0; (i<shadowVPs->size() && i<5); i++) {
-            shadowMVPs[i] = shadowVPs->at(i) * modelMatrix;
+        for(unsigned int i = 0; (i<additionalMatrices->size() && i<5); i++) {
+            shadowMVPs[i] = additionalMatrices->at(i) * modelMatrix;
         }
         glUniformMatrix4fv(shader->getUniformLocation("shadowMVPs"),
                 sizeof(shadowMVPs), false, (GLfloat*) shadowMVPs);
     }
+    else {
+        if (additionalMatrices) {
+            shader->setUniform("modelViewMatrix", additionalMatrices->at(0) * modelMatrix);
+        }
+    }
     glm::mat4 mvp = (*viewProjectionMatrix) * modelMatrix;
     shader->setUniform("modelViewProjectionMatrix", mvp);
     // draw
diff --git a/object.hh b/object.hh
index 7d21956..3b80f2b 100644
--- a/object.hh
+++ b/object.hh
@@ -16,7 +16,7 @@ class Object : public Entity {
         Object();
         ~Object();
         void render(ACGL::OpenGL::SharedShaderProgram shader, bool lightingPass,
-            glm::mat4* viewProjcetionMatrix, std::vector<glm::mat4>* shadowVPs);
+            glm::mat4* viewProjcetionMatrix, std::vector<glm::mat4>* additionalMatrices);
     private:
         Model model;
         Material material;