Cascaded shadow maps for models.

2025-08-04 08:45:16 +02:00 · 2014-05-29 15:30:40 -07:00 · 2014-05-29 15:30:40 -07:00 · 391902f79b
commit 391902f79b
parent 09231f01f3
7 changed files with 440 additions and 17 deletions
--- a/interface/resources/shaders/cascaded_shadow_map.frag
+++ b/interface/resources/shaders/cascaded_shadow_map.frag
@ -11,10 +11,15 @@
 //  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;

@ -22,8 +27,14 @@ varying vec4 shadowColor;
 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 texCoord = vec3(dot(gl_EyePlaneS[shadowIndex], position), dot(gl_EyePlaneT[shadowIndex], position),
+    vec3 shadowTexCoord = vec3(dot(gl_EyePlaneS[shadowIndex], position), dot(gl_EyePlaneT[shadowIndex], position),
        dot(gl_EyePlaneR[shadowIndex], position));
-    gl_FragColor = mix(shadowColor, gl_Color, shadow2D(shadowMap, texCoord).r);
+    
+    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));
 }
--- a/interface/resources/shaders/model_cascaded_shadow_map.frag
+++ b/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);
+}
--- a/interface/resources/shaders/model_cascaded_shadow_normal_map.frag
+++ b/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);
+}
--- a/interface/resources/shaders/model_cascaded_shadow_normal_specular_map.frag
+++ b/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);
+}
--- a/interface/resources/shaders/model_cascaded_shadow_specular_map.frag
+++ b/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);
+}
--- a/interface/src/renderer/Model.cpp
+++ b/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,12 +82,19 @@ 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;

 Model::SkinLocations Model::_skinLocations;
 Model::SkinLocations Model::_skinNormalMapLocations;
@ -92,6 +104,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) {
@ -132,6 +148,8 @@ void Model::initSkinProgram(ProgramObject& program, Model::SkinLocations& locati
    program.setUniformValue("normalMap", 1);
    program.setUniformValue("specularMap", specularTextureUnit);
    program.setUniformValue("shadowMap", shadowTextureUnit);
+    program.setUniformValue("shadowDistances", -SHADOW_MATRIX_DISTANCES[1],
+        -SHADOW_MATRIX_DISTANCES[2], -SHADOW_MATRIX_DISTANCES[3]);
    program.release();
 }

@ -229,7 +247,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();
        
        
@ -279,10 +297,69 @@ 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);
+        _cascadedShadowMapProgram.setUniformValue("shadowDistances", -SHADOW_MATRIX_DISTANCES[1],
+            -SHADOW_MATRIX_DISTANCES[2], -SHADOW_MATRIX_DISTANCES[3]);
+        _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);
+        _cascadedShadowNormalMapProgram.setUniformValue("shadowDistances", -SHADOW_MATRIX_DISTANCES[1],
+            -SHADOW_MATRIX_DISTANCES[2], -SHADOW_MATRIX_DISTANCES[3]);
+        _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);
+        _cascadedShadowSpecularMapProgram.setUniformValue("shadowDistances", -SHADOW_MATRIX_DISTANCES[1],
+            -SHADOW_MATRIX_DISTANCES[2], -SHADOW_MATRIX_DISTANCES[3]);
+        _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);
+        _cascadedShadowNormalSpecularMapProgram.setUniformValue("shadowDistances", -SHADOW_MATRIX_DISTANCES[1],
+            -SHADOW_MATRIX_DISTANCES[2], -SHADOW_MATRIX_DISTANCES[3]);
+        _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");
@ -353,6 +430,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,
@ -1508,6 +1618,7 @@ void Model::renderMeshes(float alpha, RenderMode mode, bool translucent, bool re
    const FBXGeometry& geometry = _geometry->getFBXGeometry();
    const QVector<NetworkMesh>& networkMeshes = _geometry->getMeshes();
    
+    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);
@ -1529,6 +1640,7 @@ void Model::renderMeshes(float alpha, RenderMode mode, bool translucent, bool re
        ProgramObject* program = &_program;
        ProgramObject* skinProgram = &_skinProgram;
        SkinLocations* skinLocations = &_skinLocations;
+        int tangentLocation = _normalMapTangentLocation;
        GLenum specularTextureUnit = 0;
        GLenum shadowTextureUnit = 0;
        if (mode == SHADOW_RENDER_MODE) {
@ -1539,21 +1651,38 @@ 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;
+                    } 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;
+                } else {
+                    program = &_shadowNormalMapProgram;
+                    skinProgram = &_skinShadowNormalMapProgram;
+                    skinLocations = &_skinShadowNormalMapLocations;
+                    tangentLocation = _shadowNormalMapTangentLocation;
+                }
                shadowTextureUnit = GL_TEXTURE2;
            } else {
                program = &_normalMapProgram;
@ -1562,9 +1691,15 @@ 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;
+                } else {
+                    program = &_shadowSpecularMapProgram;
+                    skinProgram = &_skinShadowSpecularMapProgram;
+                    skinLocations = &_skinShadowSpecularMapLocations;
+                }
                shadowTextureUnit = GL_TEXTURE2;
            } else {
                program = &_specularMapProgram;
@ -1574,15 +1709,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);
        
--- a/interface/src/renderer/Model.h
+++ b/interface/src/renderer/Model.h
@ -280,6 +280,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;
@ -292,12 +297,19 @@ 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;
    
    class SkinLocations {
    public:
@ -315,6 +327,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,