Merge pull request #2955 from ey6es/cascade

Basic cascaded shadow maps for increased shadow draw distance.

interface/resources/shaders/cascaded_shadow_map.frag

@@ -0,0 +1,40 @@
+#version 120
+
+//
+//  cascaded_shadow_map.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 5/29/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// the shadow texture
+uniform sampler2DShadow shadowMap;
+
+// the distances to the cascade sections
+uniform vec3 shadowDistances;
+
+// the inverse of the size of the shadow map
+const float shadowScale = 1.0 / 2048.0;
+
+// the color in shadow
+varying vec4 shadowColor;
+
+// the interpolated position
+varying vec4 position;
+
+void main(void) {
+    // compute the index of the cascade to use and the corresponding texture coordinates
+    int shadowIndex = int(dot(step(vec3(position.z), shadowDistances), vec3(1.0, 1.0, 1.0)));
+    vec3 shadowTexCoord = vec3(dot(gl_EyePlaneS[shadowIndex], position), dot(gl_EyePlaneT[shadowIndex], position),
+        dot(gl_EyePlaneR[shadowIndex], position));
+    
+    gl_FragColor = mix(shadowColor, gl_Color, 0.25 *
+        (shadow2D(shadowMap, shadowTexCoord + vec3(-shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(-shadowScale, shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(shadowScale, shadowScale, 0.0)).r));
+}

interface/resources/shaders/cascaded_shadow_map.vert

@@ -0,0 +1,33 @@
+#version 120
+
+//
+//  cascaded_shadow_map.vert
+//  vertex shader
+//
+//  Created by Andrzej Kapolka on 5/29/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// the color in shadow
+varying vec4 shadowColor;
+
+// the interpolated position
+varying vec4 position;
+
+void main(void) {
+    // the shadow color includes only the ambient terms
+    shadowColor = gl_Color * (gl_LightModel.ambient + gl_LightSource[0].ambient);
+    
+    // the normal color includes diffuse
+    vec4 normal = normalize(gl_ModelViewMatrix * vec4(gl_Normal, 0.0));
+    gl_FrontColor = shadowColor + gl_Color * (gl_LightSource[0].diffuse * max(0.0, dot(normal, gl_LightSource[0].position)));
+    
+    // generate the shadow texture coordinates using the eye position
+    position = gl_ModelViewMatrix * gl_Vertex;
+    
+    // use the fixed function transform
+    gl_Position = ftransform();
+}

interface/resources/shaders/model_cascaded_shadow_map.frag

@@ -0,0 +1,56 @@
+#version 120
+
+//
+//  model_cascaded_shadow_map.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 5/29/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// the diffuse texture
+uniform sampler2D diffuseMap;
+
+// the shadow texture
+uniform sampler2DShadow shadowMap;
+
+// the distances to the cascade sections
+uniform vec3 shadowDistances;
+
+// the inverse of the size of the shadow map
+const float shadowScale = 1.0 / 2048.0;
+
+// the interpolated position
+varying vec4 position;
+
+// the interpolated normal
+varying vec4 normal;
+
+void main(void) {
+    // compute the index of the cascade to use and the corresponding texture coordinates
+    int shadowIndex = int(dot(step(vec3(position.z), shadowDistances), vec3(1.0, 1.0, 1.0)));
+    vec3 shadowTexCoord = vec3(dot(gl_EyePlaneS[shadowIndex], position), dot(gl_EyePlaneT[shadowIndex], position),
+        dot(gl_EyePlaneR[shadowIndex], position));
+        
+    // compute the base color based on OpenGL lighting model
+    vec4 normalizedNormal = normalize(normal);
+    float diffuse = dot(normalizedNormal, gl_LightSource[0].position);
+    float facingLight = step(0.0, diffuse) * 0.25 *
+        (shadow2D(shadowMap, shadowTexCoord + vec3(-shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(-shadowScale, shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(shadowScale, shadowScale, 0.0)).r);
+    vec4 base = gl_Color * (gl_FrontLightModelProduct.sceneColor + gl_FrontLightProduct[0].ambient +
+        gl_FrontLightProduct[0].diffuse * (diffuse * facingLight));
+
+    // compute the specular component (sans exponent)
+    float specular = facingLight * max(0.0, dot(normalize(gl_LightSource[0].position - normalize(vec4(position.xyz, 0.0))),
+        normalizedNormal));
+    
+    // modulate texture by base color and add specular contribution
+    gl_FragColor = base * texture2D(diffuseMap, gl_TexCoord[0].st) +
+        vec4(pow(specular, gl_FrontMaterial.shininess) * gl_FrontLightProduct[0].specular.rgb, 0.0);
+}

interface/resources/shaders/model_cascaded_shadow_normal_map.frag

@@ -0,0 +1,69 @@
+#version 120
+
+//
+//  model_cascaded_shadow_normal_map.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 5/29/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// the diffuse texture
+uniform sampler2D diffuseMap;
+
+// the normal map texture
+uniform sampler2D normalMap;
+
+// the shadow texture
+uniform sampler2DShadow shadowMap;
+
+// the distances to the cascade sections
+uniform vec3 shadowDistances;
+
+// the inverse of the size of the shadow map
+const float shadowScale = 1.0 / 2048.0;
+
+// the interpolated position
+varying vec4 interpolatedPosition;
+
+// the interpolated normal
+varying vec4 interpolatedNormal;
+
+// the interpolated tangent
+varying vec4 interpolatedTangent;
+
+void main(void) {
+    vec3 normalizedNormal = normalize(vec3(interpolatedNormal));
+    vec3 normalizedTangent = normalize(vec3(interpolatedTangent));
+    vec3 normalizedBitangent = normalize(cross(normalizedNormal, normalizedTangent));
+    vec3 localNormal = vec3(texture2D(normalMap, gl_TexCoord[0].st)) * 2.0 - vec3(1.0, 1.0, 1.0);
+
+    // compute the index of the cascade to use and the corresponding texture coordinates
+    int shadowIndex = int(dot(step(vec3(interpolatedPosition.z), shadowDistances), vec3(1.0, 1.0, 1.0)));
+    vec3 shadowTexCoord = vec3(dot(gl_EyePlaneS[shadowIndex], interpolatedPosition),
+        dot(gl_EyePlaneT[shadowIndex], interpolatedPosition),
+        dot(gl_EyePlaneR[shadowIndex], interpolatedPosition));
+        
+    // compute the base color based on OpenGL lighting model
+    vec4 viewNormal = vec4(normalizedTangent * localNormal.x +
+        normalizedBitangent * localNormal.y + normalizedNormal * localNormal.z, 0.0);
+    float diffuse = dot(viewNormal, gl_LightSource[0].position);
+    float facingLight = step(0.0, diffuse) * 0.25 *
+        (shadow2D(shadowMap, shadowTexCoord + vec3(-shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(-shadowScale, shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(shadowScale, shadowScale, 0.0)).r);
+    vec4 base = gl_Color * (gl_FrontLightModelProduct.sceneColor + gl_FrontLightProduct[0].ambient +
+        gl_FrontLightProduct[0].diffuse * (diffuse * facingLight));
+
+    // compute the specular component (sans exponent)
+    float specular = facingLight * max(0.0, dot(normalize(gl_LightSource[0].position -
+        normalize(vec4(vec3(interpolatedPosition), 0.0))), viewNormal));
+        
+    // modulate texture by base color and add specular contribution
+    gl_FragColor = base * texture2D(diffuseMap, gl_TexCoord[0].st) +
+        vec4(pow(specular, gl_FrontMaterial.shininess) * gl_FrontLightProduct[0].specular.rgb, 0.0);
+}

interface/resources/shaders/model_cascaded_shadow_normal_specular_map.frag

@@ -0,0 +1,72 @@
+#version 120
+
+//
+//  model_cascaded_shadow_normal_specular_map.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 5/29/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// the diffuse texture
+uniform sampler2D diffuseMap;
+
+// the normal map texture
+uniform sampler2D normalMap;
+
+// the specular map texture
+uniform sampler2D specularMap;
+
+// the shadow texture
+uniform sampler2DShadow shadowMap;
+
+// the distances to the cascade sections
+uniform vec3 shadowDistances;
+
+// the inverse of the size of the shadow map
+const float shadowScale = 1.0 / 2048.0;
+
+// the interpolated position
+varying vec4 interpolatedPosition;
+
+// the interpolated normal
+varying vec4 interpolatedNormal;
+
+// the interpolated tangent
+varying vec4 interpolatedTangent;
+
+void main(void) {
+    vec3 normalizedNormal = normalize(vec3(interpolatedNormal));
+    vec3 normalizedTangent = normalize(vec3(interpolatedTangent));
+    vec3 normalizedBitangent = normalize(cross(normalizedNormal, normalizedTangent));
+    vec3 localNormal = vec3(texture2D(normalMap, gl_TexCoord[0].st)) * 2.0 - vec3(1.0, 1.0, 1.0);
+
+    // compute the index of the cascade to use and the corresponding texture coordinates
+    int shadowIndex = int(dot(step(vec3(interpolatedPosition.z), shadowDistances), vec3(1.0, 1.0, 1.0)));
+    vec3 shadowTexCoord = vec3(dot(gl_EyePlaneS[shadowIndex], interpolatedPosition),
+        dot(gl_EyePlaneT[shadowIndex], interpolatedPosition),
+        dot(gl_EyePlaneR[shadowIndex], interpolatedPosition));
+
+    // compute the base color based on OpenGL lighting model
+    vec4 viewNormal = vec4(normalizedTangent * localNormal.x +
+        normalizedBitangent * localNormal.y + normalizedNormal * localNormal.z, 0.0);
+    float diffuse = dot(viewNormal, gl_LightSource[0].position);
+    float facingLight = step(0.0, diffuse) * 0.25 *
+        (shadow2D(shadowMap, shadowTexCoord + vec3(-shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(-shadowScale, shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, shadowTexCoord + vec3(shadowScale, shadowScale, 0.0)).r);
+    vec4 base = gl_Color * (gl_FrontLightModelProduct.sceneColor + gl_FrontLightProduct[0].ambient +
+        gl_FrontLightProduct[0].diffuse * (diffuse * facingLight));
+
+    // compute the specular component (sans exponent)
+    float specular = facingLight * max(0.0, dot(normalize(gl_LightSource[0].position -
+        normalize(vec4(interpolatedPosition.xyz, 0.0))), viewNormal));
+        
+    // modulate texture by base color and add specular contribution
+    gl_FragColor = base * texture2D(diffuseMap, gl_TexCoord[0].st) + vec4(pow(specular, gl_FrontMaterial.shininess) *
+        gl_FrontLightProduct[0].specular.rgb * texture2D(specularMap, gl_TexCoord[0].st).rgb, 0.0);
+}

interface/resources/shaders/model_cascaded_shadow_specular_map.frag

@@ -0,0 +1,59 @@
+#version 120
+
+//
+//  model_cascaded_shadow_specular_map.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 5/29/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// the diffuse texture
+uniform sampler2D diffuseMap;
+
+// the specular texture
+uniform sampler2D specularMap;
+
+// the shadow texture
+uniform sampler2DShadow shadowMap;
+
+// the distances to the cascade sections
+uniform vec3 shadowDistances;
+
+// the inverse of the size of the shadow map
+const float shadowScale = 1.0 / 2048.0;
+
+// the interpolated position in view space
+varying vec4 position;
+
+// the interpolated normal
+varying vec4 normal;
+
+void main(void) {
+    // compute the index of the cascade to use and the corresponding texture coordinates
+    int shadowIndex = int(dot(step(vec3(position.z), shadowDistances), vec3(1.0, 1.0, 1.0)));
+    vec3 shadowTexCoord = vec3(dot(gl_EyePlaneS[shadowIndex], position), dot(gl_EyePlaneT[shadowIndex], position),
+        dot(gl_EyePlaneR[shadowIndex], position));
+
+    // compute the base color based on OpenGL lighting model
+    vec4 normalizedNormal = normalize(normal);
+    float diffuse = dot(normalizedNormal, gl_LightSource[0].position);
+    float facingLight = step(0.0, diffuse) * 0.25 *
+        (shadow2D(shadowMap, gl_TexCoord[1].stp + vec3(-shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, gl_TexCoord[1].stp + vec3(-shadowScale, shadowScale, 0.0)).r +
+        shadow2D(shadowMap, gl_TexCoord[1].stp + vec3(shadowScale, -shadowScale, 0.0)).r +
+        shadow2D(shadowMap, gl_TexCoord[1].stp + vec3(shadowScale, shadowScale, 0.0)).r);
+    vec4 base = gl_Color * (gl_FrontLightModelProduct.sceneColor + gl_FrontLightProduct[0].ambient +
+        gl_FrontLightProduct[0].diffuse * (diffuse * facingLight));
+
+    // compute the specular component (sans exponent)
+    float specular = facingLight * max(0.0, dot(normalize(gl_LightSource[0].position - normalize(vec4(position.xyz, 0.0))),
+        normalizedNormal));
+        
+    // modulate texture by base color and add specular contribution
+    gl_FragColor = base * texture2D(diffuseMap, gl_TexCoord[0].st) + vec4(pow(specular, gl_FrontMaterial.shininess) *
+        gl_FrontLightProduct[0].specular.rgb * texture2D(specularMap, gl_TexCoord[0].st).rgb, 0.0);
+}

interface/resources/shaders/shadow_map.frag

@@ -16,6 +16,7 @@ uniform sampler2DShadow shadowMap;
 // the inverse of the size of the shadow map
 const float shadowScale = 1.0 / 2048.0;
 
+// the color in shadow
 varying vec4 shadowColor;
 
 void main(void) {

interface/resources/shaders/shadow_map.vert

@@ -11,6 +11,7 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+// the color in shadow
 varying vec4 shadowColor;
 
 void main(void) {
@@ -21,10 +22,10 @@ void main(void) {
     vec4 normal = normalize(gl_ModelViewMatrix * vec4(gl_Normal, 0.0));
     gl_FrontColor = shadowColor + gl_Color * (gl_LightSource[0].diffuse * max(0.0, dot(normal, gl_LightSource[0].position)));
     
-    // generate the shadow texture coordinate using the eye position
+    // generate the shadow texture coordinates using the eye position
     vec4 eyePosition = gl_ModelViewMatrix * gl_Vertex;
     gl_TexCoord[0] = vec4(dot(gl_EyePlaneS[0], eyePosition), dot(gl_EyePlaneT[0], eyePosition),
-        dot(gl_EyePlaneR[0], eyePosition), 1.0); 
+        dot(gl_EyePlaneR[0], eyePosition), 1.0);
     
     // use the fixed function transform
     gl_Position = ftransform();

interface/src/Application.cpp

@@ -620,7 +620,7 @@ void Application::paintGL() {
         whichCamera = _viewFrustumOffsetCamera;
     }
 
-    if (Menu::getInstance()->isOptionChecked(MenuOption::Shadows)) {
+    if (Menu::getInstance()->getShadowsEnabled()) {
         updateShadowMap();
     }
 
@@ -2323,94 +2323,116 @@ void Application::updateShadowMap() {
     glEnable(GL_DEPTH_TEST);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    glViewport(0, 0, fbo->width(), fbo->height());
-
     glm::vec3 lightDirection = -getSunDirection();
     glm::quat rotation = rotationBetween(IDENTITY_FRONT, lightDirection);
     glm::quat inverseRotation = glm::inverse(rotation);
-    float nearScale = 0.0f;
-    const float MAX_SHADOW_DISTANCE = 2.0f;
-    float farScale = (MAX_SHADOW_DISTANCE - _viewFrustum.getNearClip()) /
-        (_viewFrustum.getFarClip() - _viewFrustum.getNearClip());
+    
+    const float SHADOW_MATRIX_DISTANCES[] = { 0.0f, 2.0f, 6.0f, 14.0f, 30.0f };
+    const glm::vec2 MAP_COORDS[] = { glm::vec2(0.0f, 0.0f), glm::vec2(0.5f, 0.0f),
+        glm::vec2(0.0f, 0.5f), glm::vec2(0.5f, 0.5f) };
+    
+    float frustumScale = 1.0f / (_viewFrustum.getFarClip() - _viewFrustum.getNearClip());
     loadViewFrustum(_myCamera, _viewFrustum);
-    glm::vec3 points[] = {
-        glm::mix(_viewFrustum.getNearTopLeft(), _viewFrustum.getFarTopLeft(), nearScale),
-        glm::mix(_viewFrustum.getNearTopRight(), _viewFrustum.getFarTopRight(), nearScale),
-        glm::mix(_viewFrustum.getNearBottomLeft(), _viewFrustum.getFarBottomLeft(), nearScale),
-        glm::mix(_viewFrustum.getNearBottomRight(), _viewFrustum.getFarBottomRight(), nearScale),
-        glm::mix(_viewFrustum.getNearTopLeft(), _viewFrustum.getFarTopLeft(), farScale),
-        glm::mix(_viewFrustum.getNearTopRight(), _viewFrustum.getFarTopRight(), farScale),
-        glm::mix(_viewFrustum.getNearBottomLeft(), _viewFrustum.getFarBottomLeft(), farScale),
-        glm::mix(_viewFrustum.getNearBottomRight(), _viewFrustum.getFarBottomRight(), farScale) };
-    glm::vec3 center;
-    for (size_t i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
-        center += points[i];
-    }
-    center /= (float)(sizeof(points) / sizeof(points[0]));
-    float radius = 0.0f;
-    for (size_t i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
-        radius = qMax(radius, glm::distance(points[i], center));
-    }
-    center = inverseRotation * center;
     
-    // to reduce texture "shimmer," move in texel increments
-    float texelSize = (2.0f * radius) / fbo->width();
-    center = glm::vec3(roundf(center.x / texelSize) * texelSize, roundf(center.y / texelSize) * texelSize,
-        roundf(center.z / texelSize) * texelSize);
+    int matrixCount = 1;
+    int targetSize = fbo->width();
+    float targetScale = 1.0f;
+    if (Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows)) {
+        matrixCount = CASCADED_SHADOW_MATRIX_COUNT;
+        targetSize = fbo->width() / 2;
+        targetScale = 0.5f;
+    }
+    for (int i = 0; i < matrixCount; i++) {
+        const glm::vec2& coord = MAP_COORDS[i];
+        glViewport(coord.s * fbo->width(), coord.t * fbo->height(), targetSize, targetSize);
+
+        float nearScale = SHADOW_MATRIX_DISTANCES[i] * frustumScale;
+        float farScale = SHADOW_MATRIX_DISTANCES[i + 1] * frustumScale;
+        glm::vec3 points[] = {
+            glm::mix(_viewFrustum.getNearTopLeft(), _viewFrustum.getFarTopLeft(), nearScale),
+            glm::mix(_viewFrustum.getNearTopRight(), _viewFrustum.getFarTopRight(), nearScale),
+            glm::mix(_viewFrustum.getNearBottomLeft(), _viewFrustum.getFarBottomLeft(), nearScale),
+            glm::mix(_viewFrustum.getNearBottomRight(), _viewFrustum.getFarBottomRight(), nearScale),
+            glm::mix(_viewFrustum.getNearTopLeft(), _viewFrustum.getFarTopLeft(), farScale),
+            glm::mix(_viewFrustum.getNearTopRight(), _viewFrustum.getFarTopRight(), farScale),
+            glm::mix(_viewFrustum.getNearBottomLeft(), _viewFrustum.getFarBottomLeft(), farScale),
+            glm::mix(_viewFrustum.getNearBottomRight(), _viewFrustum.getFarBottomRight(), farScale) };
+        glm::vec3 center;
+        for (size_t j = 0; j < sizeof(points) / sizeof(points[0]); j++) {
+            center += points[j];
+        }
+        center /= (float)(sizeof(points) / sizeof(points[0]));
+        float radius = 0.0f;
+        for (size_t j = 0; j < sizeof(points) / sizeof(points[0]); j++) {
+            radius = qMax(radius, glm::distance(points[j], center));
+        }
+        if (i < 3) {
+            const float RADIUS_SCALE = 0.5f;
+            _shadowDistances[i] = -glm::distance(_viewFrustum.getPosition(), center) - radius * RADIUS_SCALE;
+        }
+        center = inverseRotation * center;
+        
+        // to reduce texture "shimmer," move in texel increments
+        float texelSize = (2.0f * radius) / targetSize;
+        center = glm::vec3(roundf(center.x / texelSize) * texelSize, roundf(center.y / texelSize) * texelSize,
+            roundf(center.z / texelSize) * texelSize);
+        
+        glm::vec3 minima(center.x - radius, center.y - radius, center.z - radius);
+        glm::vec3 maxima(center.x + radius, center.y + radius, center.z + radius);
+
+        // stretch out our extents in z so that we get all of the avatars
+        minima.z -= _viewFrustum.getFarClip() * 0.5f;
+        maxima.z += _viewFrustum.getFarClip() * 0.5f;
+
+        // save the combined matrix for rendering
+        _shadowMatrices[i] = glm::transpose(glm::translate(glm::vec3(coord, 0.0f)) *
+            glm::scale(glm::vec3(targetScale, targetScale, 1.0f)) *
+            glm::translate(glm::vec3(0.5f, 0.5f, 0.5f)) * glm::scale(glm::vec3(0.5f, 0.5f, 0.5f)) *
+            glm::ortho(minima.x, maxima.x, minima.y, maxima.y, -maxima.z, -minima.z) * glm::mat4_cast(inverseRotation));
+
+        // update the shadow view frustum
+        _shadowViewFrustum.setPosition(rotation * ((minima + maxima) * 0.5f));
+        _shadowViewFrustum.setOrientation(rotation);
+        _shadowViewFrustum.setOrthographic(true);
+        _shadowViewFrustum.setWidth(maxima.x - minima.x);
+        _shadowViewFrustum.setHeight(maxima.y - minima.y);
+        _shadowViewFrustum.setNearClip(minima.z);
+        _shadowViewFrustum.setFarClip(maxima.z);
+        _shadowViewFrustum.setEyeOffsetPosition(glm::vec3());
+        _shadowViewFrustum.setEyeOffsetOrientation(glm::quat());
+        _shadowViewFrustum.calculate();
+
+        glMatrixMode(GL_PROJECTION);
+        glPushMatrix();
+        glLoadIdentity();
+        glOrtho(minima.x, maxima.x, minima.y, maxima.y, -maxima.z, -minima.z);
+
+        glMatrixMode(GL_MODELVIEW);
+        glPushMatrix();
+        glLoadIdentity();
+        glm::vec3 axis = glm::axis(inverseRotation);
+        glRotatef(glm::degrees(glm::angle(inverseRotation)), axis.x, axis.y, axis.z);
+
+        // store view matrix without translation, which we'll use for precision-sensitive objects
+        updateUntranslatedViewMatrix();
+
+        glEnable(GL_POLYGON_OFFSET_FILL);
+        glPolygonOffset(1.1f, 4.0f); // magic numbers courtesy http://www.eecs.berkeley.edu/~ravir/6160/papers/shadowmaps.ppt
+
+        _avatarManager.renderAvatars(Avatar::SHADOW_RENDER_MODE);
+        _particles.render(OctreeRenderer::SHADOW_RENDER_MODE);
+        _models.render(OctreeRenderer::SHADOW_RENDER_MODE);
+
+        glDisable(GL_POLYGON_OFFSET_FILL);
+
+        glPopMatrix();
+
+        glMatrixMode(GL_PROJECTION);
+        glPopMatrix();
+
+        glMatrixMode(GL_MODELVIEW);
+    }
     
-    glm::vec3 minima(center.x - radius, center.y - radius, center.z - radius);
-    glm::vec3 maxima(center.x + radius, center.y + radius, center.z + radius);
-
-    // stretch out our extents in z so that we get all of the avatars
-    minima.z -= _viewFrustum.getFarClip() * 0.5f;
-    maxima.z += _viewFrustum.getFarClip() * 0.5f;
-
-    // save the combined matrix for rendering
-    _shadowMatrix = glm::transpose(glm::translate(glm::vec3(0.5f, 0.5f, 0.5f)) * glm::scale(glm::vec3(0.5f, 0.5f, 0.5f)) *
-        glm::ortho(minima.x, maxima.x, minima.y, maxima.y, -maxima.z, -minima.z) * glm::mat4_cast(inverseRotation));
-
-    // update the shadow view frustum
-    _shadowViewFrustum.setPosition(rotation * ((minima + maxima) * 0.5f));
-    _shadowViewFrustum.setOrientation(rotation);
-    _shadowViewFrustum.setOrthographic(true);
-    _shadowViewFrustum.setWidth(maxima.x - minima.x);
-    _shadowViewFrustum.setHeight(maxima.y - minima.y);
-    _shadowViewFrustum.setNearClip(minima.z);
-    _shadowViewFrustum.setFarClip(maxima.z);
-    _shadowViewFrustum.setEyeOffsetPosition(glm::vec3());
-    _shadowViewFrustum.setEyeOffsetOrientation(glm::quat());
-    _shadowViewFrustum.calculate();
-
-    glMatrixMode(GL_PROJECTION);
-    glPushMatrix();
-    glLoadIdentity();
-    glOrtho(minima.x, maxima.x, minima.y, maxima.y, -maxima.z, -minima.z);
-
-    glMatrixMode(GL_MODELVIEW);
-    glPushMatrix();
-    glLoadIdentity();
-    glm::vec3 axis = glm::axis(inverseRotation);
-    glRotatef(glm::degrees(glm::angle(inverseRotation)), axis.x, axis.y, axis.z);
-
-    // store view matrix without translation, which we'll use for precision-sensitive objects
-    updateUntranslatedViewMatrix();
-
-    glEnable(GL_POLYGON_OFFSET_FILL);
-    glPolygonOffset(1.1f, 4.0f); // magic numbers courtesy http://www.eecs.berkeley.edu/~ravir/6160/papers/shadowmaps.ppt
-
-    _avatarManager.renderAvatars(Avatar::SHADOW_RENDER_MODE);
-    _particles.render(OctreeRenderer::SHADOW_RENDER_MODE);
-    _models.render(OctreeRenderer::SHADOW_RENDER_MODE);
-
-    glDisable(GL_POLYGON_OFFSET_FILL);
-
-    glPopMatrix();
-
-    glMatrixMode(GL_PROJECTION);
-    glPopMatrix();
-
-    glMatrixMode(GL_MODELVIEW);
-
     fbo->release();
 
     glViewport(0, 0, _glWidget->width(), _glWidget->height());
@@ -2495,6 +2517,20 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
         setupWorldLight();
     }
 
+    // setup shadow matrices (again, after the camera transform)
+    int shadowMatrixCount = 0;
+    if (Menu::getInstance()->isOptionChecked(MenuOption::SimpleShadows)) {
+        shadowMatrixCount = 1;
+    } else if (Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows)) {
+        shadowMatrixCount = CASCADED_SHADOW_MATRIX_COUNT;
+    }
+    for (int i = shadowMatrixCount - 1; i >= 0; i--) {
+        glActiveTexture(GL_TEXTURE0 + i);
+        glTexGenfv(GL_S, GL_EYE_PLANE, (const GLfloat*)&_shadowMatrices[i][0]);
+        glTexGenfv(GL_T, GL_EYE_PLANE, (const GLfloat*)&_shadowMatrices[i][1]);
+        glTexGenfv(GL_R, GL_EYE_PLANE, (const GLfloat*)&_shadowMatrices[i][2]);
+    }
+
     if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Stars)) {
         PerformanceTimer perfTimer("paintGL/displaySide/stars");
         PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),

interface/src/Application.h

@@ -261,11 +261,11 @@ public:
     /// result from matrix multiplication at high translation magnitudes.
     void loadTranslatedViewMatrix(const glm::vec3& translation);
 
-    const glm::mat4& getShadowMatrix() const { return _shadowMatrix; }
-
     void getModelViewMatrix(glm::dmat4* modelViewMatrix);
     void getProjectionMatrix(glm::dmat4* projectionMatrix);
 
+    const glm::vec3& getShadowDistances() const { return _shadowDistances; }
+
     /// Computes the off-axis frustum parameters for the view frustum, taking mirroring into account.
     void computeOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& nearVal,
         float& farVal, glm::vec4& nearClipPlane, glm::vec4& farClipPlane) const;
@@ -492,7 +492,9 @@ private:
     float _rotateMirror;
     float _raiseMirror;
 
-    glm::mat4 _shadowMatrix;
+    static const int CASCADED_SHADOW_MATRIX_COUNT = 4;
+    glm::mat4 _shadowMatrices[CASCADED_SHADOW_MATRIX_COUNT];
+    glm::vec3 _shadowDistances;
 
     Environment _environment;
 

interface/src/Menu.cpp

@@ -315,7 +315,12 @@ Menu::Menu() :
                                   appInstance->getGlowEffect(),
                                   SLOT(cycleRenderMode()));
 
-    addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Shadows, 0, false);
+    QMenu* shadowMenu = renderOptionsMenu->addMenu("Shadows");
+    QActionGroup* shadowGroup = new QActionGroup(shadowMenu);
+    shadowGroup->addAction(addCheckableActionToQMenuAndActionHash(shadowMenu, "None", 0, true));
+    shadowGroup->addAction(addCheckableActionToQMenuAndActionHash(shadowMenu, MenuOption::SimpleShadows, 0, false));
+    shadowGroup->addAction(addCheckableActionToQMenuAndActionHash(shadowMenu, MenuOption::CascadedShadows, 0, false));
+    
     addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Metavoxels, 0, true);
     addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::BuckyBalls, 0, false);
     addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Particles, 0, true);
@@ -688,6 +693,10 @@ void Menu::scanMenu(QMenu* menu, settingsAction modifySetting, QSettings* set) {
     set->endGroup();
 }
 
+bool Menu::getShadowsEnabled() const {
+    return isOptionChecked(MenuOption::SimpleShadows) || isOptionChecked(MenuOption::CascadedShadows);
+}
+
 void Menu::handleViewFrustumOffsetKeyModifier(int key) {
     const float VIEW_FRUSTUM_OFFSET_DELTA = 0.5f;
     const float VIEW_FRUSTUM_OFFSET_UP_DELTA = 0.05f;
@@ -858,8 +867,8 @@ void Menu::setIsOptionChecked(const QString& menuOption, bool isChecked) {
     }
 }
 
-bool Menu::isOptionChecked(const QString& menuOption) {
-    QAction* menu = _actionHash.value(menuOption);
+bool Menu::isOptionChecked(const QString& menuOption) const {
+    const QAction* menu = _actionHash.value(menuOption);
     if (menu) {
         return menu->isChecked();
     }

interface/src/Menu.h

@@ -103,6 +103,8 @@ public:
     int getMaxVoxels() const { return _maxVoxels; }
     QAction* getUseVoxelShader() const { return _useVoxelShader; }
 
+    bool getShadowsEnabled() const;
+
     void handleViewFrustumOffsetKeyModifier(int key);
 
     // User Tweakable LOD Items
@@ -171,7 +173,7 @@ public slots:
     void removeSeparator(const QString& menuName, const QString& separatorName);
     void addMenuItem(const MenuItemProperties& properties);
     void removeMenuItem(const QString& menuName, const QString& menuitem);
-    bool isOptionChecked(const QString& menuOption);
+    bool isOptionChecked(const QString& menuOption) const;
     void setIsOptionChecked(const QString& menuOption, bool isChecked);
 
 private slots:
@@ -304,6 +306,7 @@ namespace MenuOption {
     const QString Bandwidth = "Bandwidth Display";
     const QString BandwidthDetails = "Bandwidth Details";
     const QString BuckyBalls = "Bucky Balls";
+    const QString CascadedShadows = "Cascaded";
     const QString Chat = "Chat...";
     const QString ChatCircling = "Chat Circling";
     const QString CollideWithAvatars = "Collide With Avatars";
@@ -388,7 +391,7 @@ namespace MenuOption {
     const QString ScriptEditor = "Script Editor...";
     const QString SettingsExport = "Export Settings";
     const QString SettingsImport = "Import Settings";
-    const QString Shadows = "Shadows";
+    const QString SimpleShadows = "Simple";
     const QString ShowBordersVoxelNodes = "Show Voxel Nodes";
     const QString ShowBordersModelNodes = "Show Model Nodes";
     const QString ShowBordersParticleNodes = "Show Particle Nodes";

interface/src/renderer/Model.cpp

@@ -65,6 +65,11 @@ ProgramObject Model::_shadowNormalMapProgram;
 ProgramObject Model::_shadowSpecularMapProgram;
 ProgramObject Model::_shadowNormalSpecularMapProgram;
 
+ProgramObject Model::_cascadedShadowMapProgram;
+ProgramObject Model::_cascadedShadowNormalMapProgram;
+ProgramObject Model::_cascadedShadowSpecularMapProgram;
+ProgramObject Model::_cascadedShadowNormalSpecularMapProgram;
+
 ProgramObject Model::_shadowProgram;
 
 ProgramObject Model::_skinProgram;
@@ -77,13 +82,25 @@ ProgramObject Model::_skinShadowNormalMapProgram;
 ProgramObject Model::_skinShadowSpecularMapProgram;
 ProgramObject Model::_skinShadowNormalSpecularMapProgram;
 
+ProgramObject Model::_skinCascadedShadowMapProgram;
+ProgramObject Model::_skinCascadedShadowNormalMapProgram;
+ProgramObject Model::_skinCascadedShadowSpecularMapProgram;
+ProgramObject Model::_skinCascadedShadowNormalSpecularMapProgram;
+
 ProgramObject Model::_skinShadowProgram;
 
 int Model::_normalMapTangentLocation;
 int Model::_normalSpecularMapTangentLocation;
 int Model::_shadowNormalMapTangentLocation;
 int Model::_shadowNormalSpecularMapTangentLocation;
+int Model::_cascadedShadowNormalMapTangentLocation;
+int Model::_cascadedShadowNormalSpecularMapTangentLocation;
 
+int Model::_cascadedShadowMapDistancesLocation;
+int Model::_cascadedShadowNormalMapDistancesLocation;
+int Model::_cascadedShadowSpecularMapDistancesLocation;
+int Model::_cascadedShadowNormalSpecularMapDistancesLocation;
+    
 Model::SkinLocations Model::_skinLocations;
 Model::SkinLocations Model::_skinNormalMapLocations;
 Model::SkinLocations Model::_skinSpecularMapLocations;
@@ -92,6 +109,10 @@ Model::SkinLocations Model::_skinShadowMapLocations;
 Model::SkinLocations Model::_skinShadowNormalMapLocations;
 Model::SkinLocations Model::_skinShadowSpecularMapLocations;
 Model::SkinLocations Model::_skinShadowNormalSpecularMapLocations;
+Model::SkinLocations Model::_skinCascadedShadowMapLocations;
+Model::SkinLocations Model::_skinCascadedShadowNormalMapLocations;
+Model::SkinLocations Model::_skinCascadedShadowSpecularMapLocations;
+Model::SkinLocations Model::_skinCascadedShadowNormalSpecularMapLocations;
 Model::SkinLocations Model::_skinShadowLocations;
 
 void Model::setScale(const glm::vec3& scale) {
@@ -128,6 +149,7 @@ void Model::initSkinProgram(ProgramObject& program, Model::SkinLocations& locati
     locations.clusterIndices = program.attributeLocation("clusterIndices");
     locations.clusterWeights = program.attributeLocation("clusterWeights");
     locations.tangent = program.attributeLocation("tangent");
+    locations.shadowDistances = program.uniformLocation("shadowDistances");
     program.setUniformValue("diffuseMap", 0);
     program.setUniformValue("normalMap", 1);
     program.setUniformValue("specularMap", specularTextureUnit);
@@ -222,7 +244,7 @@ void Model::init() {
         _normalSpecularMapProgram.setUniformValue("diffuseMap", 0);
         _normalSpecularMapProgram.setUniformValue("normalMap", 1);
         _normalSpecularMapProgram.setUniformValue("specularMap", 2);
-        _normalSpecularMapTangentLocation = _normalMapProgram.attributeLocation("tangent");
+        _normalSpecularMapTangentLocation = _normalSpecularMapProgram.attributeLocation("tangent");
         _normalSpecularMapProgram.release();
         
         
@@ -272,10 +294,66 @@ void Model::init() {
         _shadowNormalSpecularMapProgram.setUniformValue("normalMap", 1);
         _shadowNormalSpecularMapProgram.setUniformValue("specularMap", 2);
         _shadowNormalSpecularMapProgram.setUniformValue("shadowMap", 3);
-        _shadowNormalSpecularMapTangentLocation = _normalMapProgram.attributeLocation("tangent");
+        _shadowNormalSpecularMapTangentLocation = _shadowNormalSpecularMapProgram.attributeLocation("tangent");
         _shadowNormalSpecularMapProgram.release();
         
         
+        _cascadedShadowMapProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
+            "shaders/model.vert");
+        _cascadedShadowMapProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
+            "shaders/model_cascaded_shadow_map.frag");
+        _cascadedShadowMapProgram.link();
+        
+        _cascadedShadowMapProgram.bind();
+        _cascadedShadowMapProgram.setUniformValue("diffuseMap", 0);
+        _cascadedShadowMapProgram.setUniformValue("shadowMap", 1);
+        _cascadedShadowMapDistancesLocation = _cascadedShadowMapProgram.uniformLocation("shadowDistances");
+        _cascadedShadowMapProgram.release();
+        
+        _cascadedShadowNormalMapProgram.addShaderFromSourceFile(QGLShader::Vertex,
+            Application::resourcesPath() + "shaders/model_normal_map.vert");
+        _cascadedShadowNormalMapProgram.addShaderFromSourceFile(QGLShader::Fragment,
+            Application::resourcesPath() + "shaders/model_cascaded_shadow_normal_map.frag");
+        _cascadedShadowNormalMapProgram.link();
+        
+        _cascadedShadowNormalMapProgram.bind();
+        _cascadedShadowNormalMapProgram.setUniformValue("diffuseMap", 0);
+        _cascadedShadowNormalMapProgram.setUniformValue("normalMap", 1);
+        _cascadedShadowNormalMapProgram.setUniformValue("shadowMap", 2);
+        _cascadedShadowNormalMapDistancesLocation = _cascadedShadowNormalMapProgram.uniformLocation("shadowDistances");
+        _cascadedShadowNormalMapTangentLocation = _cascadedShadowNormalMapProgram.attributeLocation("tangent");
+        _cascadedShadowNormalMapProgram.release();
+        
+        _cascadedShadowSpecularMapProgram.addShaderFromSourceFile(QGLShader::Vertex,
+            Application::resourcesPath() + "shaders/model.vert");
+        _cascadedShadowSpecularMapProgram.addShaderFromSourceFile(QGLShader::Fragment,
+            Application::resourcesPath() + "shaders/model_cascaded_shadow_specular_map.frag");
+        _cascadedShadowSpecularMapProgram.link();
+        
+        _cascadedShadowSpecularMapProgram.bind();
+        _cascadedShadowSpecularMapProgram.setUniformValue("diffuseMap", 0);
+        _cascadedShadowSpecularMapProgram.setUniformValue("specularMap", 1);
+        _cascadedShadowSpecularMapProgram.setUniformValue("shadowMap", 2);
+        _cascadedShadowSpecularMapDistancesLocation = _cascadedShadowSpecularMapProgram.uniformLocation("shadowDistances");
+        _cascadedShadowSpecularMapProgram.release();
+        
+        _cascadedShadowNormalSpecularMapProgram.addShaderFromSourceFile(QGLShader::Vertex,
+            Application::resourcesPath() + "shaders/model_normal_map.vert");
+        _cascadedShadowNormalSpecularMapProgram.addShaderFromSourceFile(QGLShader::Fragment,
+            Application::resourcesPath() + "shaders/model_cascaded_shadow_normal_specular_map.frag");
+        _cascadedShadowNormalSpecularMapProgram.link();
+        
+        _cascadedShadowNormalSpecularMapProgram.bind();
+        _cascadedShadowNormalSpecularMapProgram.setUniformValue("diffuseMap", 0);
+        _cascadedShadowNormalSpecularMapProgram.setUniformValue("normalMap", 1);
+        _cascadedShadowNormalSpecularMapProgram.setUniformValue("specularMap", 2);
+        _cascadedShadowNormalSpecularMapProgram.setUniformValue("shadowMap", 3);
+        _cascadedShadowNormalSpecularMapDistancesLocation =
+            _cascadedShadowNormalSpecularMapProgram.uniformLocation("shadowDistances");
+        _cascadedShadowNormalSpecularMapTangentLocation = _cascadedShadowNormalSpecularMapProgram.attributeLocation("tangent");
+        _cascadedShadowNormalSpecularMapProgram.release();
+        
+        
         _shadowProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() + "shaders/model_shadow.vert");
         _shadowProgram.addShaderFromSourceFile(QGLShader::Fragment,
             Application::resourcesPath() + "shaders/model_shadow.frag");
@@ -346,6 +424,39 @@ void Model::init() {
         initSkinProgram(_skinShadowNormalSpecularMapProgram, _skinShadowNormalSpecularMapLocations, 2, 3);
         
         
+        _skinCascadedShadowMapProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
+            "shaders/skin_model.vert");
+        _skinCascadedShadowMapProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
+            "shaders/model_cascaded_shadow_map.frag");
+        _skinCascadedShadowMapProgram.link();
+        
+        initSkinProgram(_skinCascadedShadowMapProgram, _skinCascadedShadowMapLocations);
+        
+        _skinCascadedShadowNormalMapProgram.addShaderFromSourceFile(QGLShader::Vertex,
+            Application::resourcesPath() + "shaders/skin_model_normal_map.vert");
+        _skinCascadedShadowNormalMapProgram.addShaderFromSourceFile(QGLShader::Fragment,
+            Application::resourcesPath() + "shaders/model_cascaded_shadow_normal_map.frag");
+        _skinCascadedShadowNormalMapProgram.link();
+        
+        initSkinProgram(_skinCascadedShadowNormalMapProgram, _skinCascadedShadowNormalMapLocations, 1, 2);
+        
+        _skinCascadedShadowSpecularMapProgram.addShaderFromSourceFile(QGLShader::Vertex,
+            Application::resourcesPath() + "shaders/skin_model.vert");
+        _skinCascadedShadowSpecularMapProgram.addShaderFromSourceFile(QGLShader::Fragment,
+            Application::resourcesPath() + "shaders/model_cascaded_shadow_specular_map.frag");
+        _skinCascadedShadowSpecularMapProgram.link();
+        
+        initSkinProgram(_skinCascadedShadowSpecularMapProgram, _skinCascadedShadowSpecularMapLocations, 1, 2);
+        
+        _skinCascadedShadowNormalSpecularMapProgram.addShaderFromSourceFile(QGLShader::Vertex,
+            Application::resourcesPath() + "shaders/skin_model_normal_map.vert");
+        _skinCascadedShadowNormalSpecularMapProgram.addShaderFromSourceFile(QGLShader::Fragment,
+            Application::resourcesPath() + "shaders/model_cascaded_shadow_normal_specular_map.frag");
+        _skinCascadedShadowNormalSpecularMapProgram.link();
+        
+        initSkinProgram(_skinCascadedShadowNormalSpecularMapProgram, _skinCascadedShadowNormalSpecularMapLocations, 2, 3);
+        
+        
         _skinShadowProgram.addShaderFromSourceFile(QGLShader::Vertex,
             Application::resourcesPath() + "shaders/skin_model_shadow.vert");
         _skinShadowProgram.addShaderFromSourceFile(QGLShader::Fragment,
@@ -501,7 +612,7 @@ bool Model::render(float alpha, RenderMode mode, bool receiveShadows) {
     glEnable(GL_ALPHA_TEST);
     glAlphaFunc(GL_GREATER, 0.5f * alpha);
     
-    receiveShadows &= Menu::getInstance()->isOptionChecked(MenuOption::Shadows);
+    receiveShadows &= Menu::getInstance()->getShadowsEnabled();
     renderMeshes(alpha, mode, false, receiveShadows);
     
     glDisable(GL_ALPHA_TEST);
@@ -1502,11 +1613,7 @@ void Model::renderMeshes(float alpha, RenderMode mode, bool translucent, bool re
     const FBXGeometry& geometry = _geometry->getFBXGeometry();
     const QVector<NetworkMesh>& networkMeshes = _geometry->getMeshes();
     
-    if (receiveShadows) {
-        glTexGenfv(GL_S, GL_EYE_PLANE, (const GLfloat*)&Application::getInstance()->getShadowMatrix()[0]);
-        glTexGenfv(GL_T, GL_EYE_PLANE, (const GLfloat*)&Application::getInstance()->getShadowMatrix()[1]);
-        glTexGenfv(GL_R, GL_EYE_PLANE, (const GLfloat*)&Application::getInstance()->getShadowMatrix()[2]);
-    }
+    bool cascadedShadows = Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows);
     for (int i = 0; i < networkMeshes.size(); i++) {
         // exit early if the translucency doesn't match what we're drawing
         const NetworkMesh& networkMesh = networkMeshes.at(i);
@@ -1528,6 +1635,8 @@ void Model::renderMeshes(float alpha, RenderMode mode, bool translucent, bool re
         ProgramObject* program = &_program;
         ProgramObject* skinProgram = &_skinProgram;
         SkinLocations* skinLocations = &_skinLocations;
+        int tangentLocation = _normalMapTangentLocation;
+        int shadowDistancesLocation = _cascadedShadowMapDistancesLocation;
         GLenum specularTextureUnit = 0;
         GLenum shadowTextureUnit = 0;
         if (mode == SHADOW_RENDER_MODE) {
@@ -1538,21 +1647,40 @@ void Model::renderMeshes(float alpha, RenderMode mode, bool translucent, bool re
         } else if (!mesh.tangents.isEmpty()) {
             if (mesh.hasSpecularTexture()) {
                 if (receiveShadows) {
-                    program = &_shadowNormalSpecularMapProgram;
-                    skinProgram = &_skinShadowNormalSpecularMapProgram;
-                    skinLocations = &_skinShadowNormalSpecularMapLocations;
+                    if (cascadedShadows) {
+                        program = &_cascadedShadowNormalSpecularMapProgram;
+                        skinProgram = &_skinCascadedShadowNormalSpecularMapProgram;
+                        skinLocations = &_skinCascadedShadowNormalSpecularMapLocations;
+                        tangentLocation = _cascadedShadowNormalSpecularMapTangentLocation;
+                        shadowDistancesLocation = _cascadedShadowNormalSpecularMapDistancesLocation;
+                    } else {
+                        program = &_shadowNormalSpecularMapProgram;
+                        skinProgram = &_skinShadowNormalSpecularMapProgram;
+                        skinLocations = &_skinShadowNormalSpecularMapLocations;
+                        tangentLocation = _shadowNormalSpecularMapTangentLocation;
+                    }
                     shadowTextureUnit = GL_TEXTURE3;
                 } else {
                     program = &_normalSpecularMapProgram;
                     skinProgram = &_skinNormalSpecularMapProgram;
                     skinLocations = &_skinNormalSpecularMapLocations;
+                    tangentLocation = _normalSpecularMapTangentLocation;
                 }
                 specularTextureUnit = GL_TEXTURE2;
                 
             } else if (receiveShadows) {
-                program = &_shadowNormalMapProgram;
-                skinProgram = &_skinShadowNormalMapProgram;
-                skinLocations = &_skinShadowNormalMapLocations;
+                if (cascadedShadows) {
+                    program = &_cascadedShadowNormalMapProgram;
+                    skinProgram = &_skinCascadedShadowNormalMapProgram;
+                    skinLocations = &_skinCascadedShadowNormalMapLocations;
+                    tangentLocation = _cascadedShadowNormalMapTangentLocation;
+                    shadowDistancesLocation = _cascadedShadowNormalMapDistancesLocation;
+                } else {
+                    program = &_shadowNormalMapProgram;
+                    skinProgram = &_skinShadowNormalMapProgram;
+                    skinLocations = &_skinShadowNormalMapLocations;
+                    tangentLocation = _shadowNormalMapTangentLocation;
+                }
                 shadowTextureUnit = GL_TEXTURE2;
             } else {
                 program = &_normalMapProgram;
@@ -1561,9 +1689,16 @@ void Model::renderMeshes(float alpha, RenderMode mode, bool translucent, bool re
             }
         } else if (mesh.hasSpecularTexture()) {
             if (receiveShadows) {
-                program = &_shadowSpecularMapProgram;
-                skinProgram = &_skinShadowSpecularMapProgram;
-                skinLocations = &_skinShadowSpecularMapLocations;
+                if (cascadedShadows) {
+                    program = &_cascadedShadowSpecularMapProgram;
+                    skinProgram = &_skinCascadedShadowSpecularMapProgram;
+                    skinLocations = &_skinCascadedShadowSpecularMapLocations;
+                    shadowDistancesLocation = _cascadedShadowSpecularMapDistancesLocation;
+                } else {
+                    program = &_shadowSpecularMapProgram;
+                    skinProgram = &_skinShadowSpecularMapProgram;
+                    skinLocations = &_skinShadowSpecularMapLocations;
+                }
                 shadowTextureUnit = GL_TEXTURE2;
             } else {
                 program = &_specularMapProgram;
@@ -1573,15 +1708,20 @@ void Model::renderMeshes(float alpha, RenderMode mode, bool translucent, bool re
             specularTextureUnit = GL_TEXTURE1;
             
         } else if (receiveShadows) {
-            program = &_shadowMapProgram;
-            skinProgram = &_skinShadowMapProgram;
-            skinLocations = &_skinShadowMapLocations;
+            if (cascadedShadows) {
+                program = &_cascadedShadowMapProgram;
+                skinProgram = &_skinCascadedShadowMapProgram;
+                skinLocations = &_skinCascadedShadowMapLocations;
+            } else {
+                program = &_shadowMapProgram;
+                skinProgram = &_skinShadowMapProgram;
+                skinLocations = &_skinShadowMapLocations;
+            }
             shadowTextureUnit = GL_TEXTURE1;
         }
         
         const MeshState& state = _meshStates.at(i);
         ProgramObject* activeProgram = program;
-        int tangentLocation = _normalMapTangentLocation;
         glPushMatrix();
         Application::getInstance()->loadTranslatedViewMatrix(_translation);
         
@@ -1599,10 +1739,15 @@ void Model::renderMeshes(float alpha, RenderMode mode, bool translucent, bool re
             skinProgram->enableAttributeArray(skinLocations->clusterWeights);
             activeProgram = skinProgram;
             tangentLocation = skinLocations->tangent;
-     
+            if (cascadedShadows) {
+                program->setUniform(skinLocations->shadowDistances, Application::getInstance()->getShadowDistances());
+            }
         } else {    
             glMultMatrixf((const GLfloat*)&state.clusterMatrices[0]);
             program->bind();
+            if (cascadedShadows) {
+                program->setUniform(shadowDistancesLocation, Application::getInstance()->getShadowDistances());
+            }
         }
 
         if (mesh.blendshapes.isEmpty()) {

interface/src/renderer/Model.h

@@ -293,6 +293,11 @@ private:
     static ProgramObject _shadowSpecularMapProgram;
     static ProgramObject _shadowNormalSpecularMapProgram;
     
+    static ProgramObject _cascadedShadowMapProgram;
+    static ProgramObject _cascadedShadowNormalMapProgram;
+    static ProgramObject _cascadedShadowSpecularMapProgram;
+    static ProgramObject _cascadedShadowNormalSpecularMapProgram;
+    
     static ProgramObject _shadowProgram;
     
     static ProgramObject _skinProgram;
@@ -305,12 +310,24 @@ private:
     static ProgramObject _skinShadowSpecularMapProgram;
     static ProgramObject _skinShadowNormalSpecularMapProgram;
     
+    static ProgramObject _skinCascadedShadowMapProgram;
+    static ProgramObject _skinCascadedShadowNormalMapProgram;
+    static ProgramObject _skinCascadedShadowSpecularMapProgram;
+    static ProgramObject _skinCascadedShadowNormalSpecularMapProgram;
+    
     static ProgramObject _skinShadowProgram;
     
     static int _normalMapTangentLocation;
     static int _normalSpecularMapTangentLocation;
     static int _shadowNormalMapTangentLocation;
     static int _shadowNormalSpecularMapTangentLocation;
+    static int _cascadedShadowNormalMapTangentLocation;
+    static int _cascadedShadowNormalSpecularMapTangentLocation;
+    
+    static int _cascadedShadowMapDistancesLocation;
+    static int _cascadedShadowNormalMapDistancesLocation;
+    static int _cascadedShadowSpecularMapDistancesLocation;
+    static int _cascadedShadowNormalSpecularMapDistancesLocation;
     
     class SkinLocations {
     public:
@@ -318,6 +335,7 @@ private:
         int clusterIndices;
         int clusterWeights;
         int tangent;
+        int shadowDistances;
     };
     
     static SkinLocations _skinLocations;
@@ -328,6 +346,10 @@ private:
     static SkinLocations _skinShadowNormalMapLocations;
     static SkinLocations _skinShadowSpecularMapLocations;
     static SkinLocations _skinShadowNormalSpecularMapLocations;
+    static SkinLocations _skinCascadedShadowMapLocations;
+    static SkinLocations _skinCascadedShadowNormalMapLocations;
+    static SkinLocations _skinCascadedShadowSpecularMapLocations;
+    static SkinLocations _skinCascadedShadowNormalSpecularMapLocations;
     static SkinLocations _skinShadowLocations;
     
     static void initSkinProgram(ProgramObject& program, SkinLocations& locations,

interface/src/voxels/VoxelSystem.cpp

@@ -519,6 +519,17 @@ void VoxelSystem::initVoxelMemory() {
             _shadowMapProgram.bind();
             _shadowMapProgram.setUniformValue("shadowMap", 0);
             _shadowMapProgram.release();
+            
+            _cascadedShadowMapProgram.addShaderFromSourceFile(QGLShader::Vertex,
+                Application::resourcesPath() + "shaders/cascaded_shadow_map.vert");
+            _cascadedShadowMapProgram.addShaderFromSourceFile(QGLShader::Fragment,
+                Application::resourcesPath() + "shaders/cascaded_shadow_map.frag");
+            _cascadedShadowMapProgram.link();
+
+            _cascadedShadowMapProgram.bind();
+            _cascadedShadowMapProgram.setUniformValue("shadowMap", 0);
+            _shadowDistancesLocation = _cascadedShadowMapProgram.uniformLocation("shadowDistances");
+            _cascadedShadowMapProgram.release();
         }
     }
     _renderer = new PrimitiveRenderer(_maxVoxels);
@@ -1166,6 +1177,8 @@ glm::vec3 VoxelSystem::computeVoxelVertex(const glm::vec3& startVertex, float vo
 
 ProgramObject VoxelSystem::_perlinModulateProgram;
 ProgramObject VoxelSystem::_shadowMapProgram;
+ProgramObject VoxelSystem::_cascadedShadowMapProgram;
+int VoxelSystem::_shadowDistancesLocation;
 
 void VoxelSystem::init() {
     if (_initialized) {
@@ -1486,14 +1499,15 @@ void VoxelSystem::render() {
 
 void VoxelSystem::applyScaleAndBindProgram(bool texture) {
 
-    if (Menu::getInstance()->isOptionChecked(MenuOption::Shadows)) {
-        _shadowMapProgram.bind();
+    if (Menu::getInstance()->getShadowsEnabled()) {
+        if (Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows)) {
+            _cascadedShadowMapProgram.bind();
+            _cascadedShadowMapProgram.setUniform(_shadowDistancesLocation, Application::getInstance()->getShadowDistances());
+        } else {
+            _shadowMapProgram.bind();
+        }
         glBindTexture(GL_TEXTURE_2D, Application::getInstance()->getTextureCache()->getShadowDepthTextureID());
 
-        glTexGenfv(GL_S, GL_EYE_PLANE, (const GLfloat*)&Application::getInstance()->getShadowMatrix()[0]);
-        glTexGenfv(GL_T, GL_EYE_PLANE, (const GLfloat*)&Application::getInstance()->getShadowMatrix()[1]);
-        glTexGenfv(GL_R, GL_EYE_PLANE, (const GLfloat*)&Application::getInstance()->getShadowMatrix()[2]);
-
     } else if (texture) {
         _perlinModulateProgram.bind();
         glBindTexture(GL_TEXTURE_2D, Application::getInstance()->getTextureCache()->getPermutationNormalTextureID());
@@ -1507,11 +1521,14 @@ void VoxelSystem::removeScaleAndReleaseProgram(bool texture) {
     // scale back down to 1 so heads aren't massive
     glPopMatrix();
 
-    if (Menu::getInstance()->isOptionChecked(MenuOption::Shadows)) {
-        _shadowMapProgram.release();
+    if (Menu::getInstance()->getShadowsEnabled()) {
+        if (Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows)) {
+            _cascadedShadowMapProgram.release();
+        } else {
+            _shadowMapProgram.release();
+        }
         glBindTexture(GL_TEXTURE_2D, 0);
         
-
     } else if (texture) {
         _perlinModulateProgram.release();
         glBindTexture(GL_TEXTURE_2D, 0);

interface/src/voxels/VoxelSystem.h

@@ -233,6 +233,8 @@ private:
 
     static ProgramObject _perlinModulateProgram;
     static ProgramObject _shadowMapProgram;
+    static ProgramObject _cascadedShadowMapProgram;
+    static int _shadowDistancesLocation;
 
     int _hookID;
     std::vector<glBufferIndex> _freeIndexes;