From 6434d983657cf47b7cf09dd7e32dfa9b02f6f15b Mon Sep 17 00:00:00 2001 From: Zach Pomerantz Date: Mon, 18 Jan 2016 11:11:28 -0800 Subject: [PATCH] Separate directional shaders with(out) shadowmaps --- .../src/DeferredLightingEffect.cpp | 7 ++- .../src/directional_ambient_light.slf | 6 +-- .../src/directional_ambient_light_shadow.slf | 51 ++++++++++++++++++ .../render-utils/src/directional_light.slf | 6 +-- .../src/directional_light_shadow.slf | 52 ++++++++++++++++++ .../src/directional_skybox_light.slf | 10 ++-- .../src/directional_skybox_light_shadow.slf | 53 +++++++++++++++++++ 7 files changed, 170 insertions(+), 15 deletions(-) create mode 100644 libraries/render-utils/src/directional_ambient_light_shadow.slf create mode 100644 libraries/render-utils/src/directional_light_shadow.slf create mode 100644 libraries/render-utils/src/directional_skybox_light_shadow.slf diff --git a/libraries/render-utils/src/DeferredLightingEffect.cpp b/libraries/render-utils/src/DeferredLightingEffect.cpp index ac18348528..5af89e7afc 100644 --- a/libraries/render-utils/src/DeferredLightingEffect.cpp +++ b/libraries/render-utils/src/DeferredLightingEffect.cpp @@ -31,6 +31,10 @@ #include "directional_ambient_light_frag.h" #include "directional_skybox_light_frag.h" +#include "directional_light_shadow_frag.h" +#include "directional_ambient_light_shadow_frag.h" +#include "directional_skybox_light_shadow_frag.h" + #include "point_light_frag.h" #include "spot_light_frag.h" @@ -47,14 +51,15 @@ struct LightLocations { static void loadLightProgram(const char* vertSource, const char* fragSource, bool lightVolume, gpu::PipelinePointer& program, LightLocationsPtr& locations); - void DeferredLightingEffect::init() { _directionalLightLocations = std::make_shared(); _directionalAmbientSphereLightLocations = std::make_shared(); _directionalSkyboxLightLocations = std::make_shared(); + _pointLightLocations = std::make_shared(); _spotLightLocations = std::make_shared(); + // TODO: To use shadowmaps, replace directional_*_light_frag with directional_*_light_shadow_frag shaders. loadLightProgram(deferred_light_vert, directional_light_frag, false, _directionalLight, _directionalLightLocations); loadLightProgram(deferred_light_vert, directional_ambient_light_frag, false, _directionalAmbientSphereLight, _directionalAmbientSphereLightLocations); loadLightProgram(deferred_light_vert, directional_skybox_light_frag, false, _directionalSkyboxLight, _directionalSkyboxLightLocations); diff --git a/libraries/render-utils/src/directional_ambient_light.slf b/libraries/render-utils/src/directional_ambient_light.slf index 5b936f566f..5c0a5c8331 100755 --- a/libraries/render-utils/src/directional_ambient_light.slf +++ b/libraries/render-utils/src/directional_ambient_light.slf @@ -6,13 +6,12 @@ // fragment shader // // Created by Andrzej Kapolka on 9/3/14. -// Copyright 2014 High Fidelity, Inc. +// Copyright 2016 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 // -<@include Shadow.slh@> <@include DeferredBuffer.slh@> <@include DeferredGlobalLight.slh@> @@ -26,8 +25,7 @@ void main(void) { DeferredTransform deferredTransform = getDeferredTransform(); DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0); - vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0); - float shadowAttenuation = evalShadowAttenuation(worldPos); + float shadowAttenuation = 1.0; if ((frag.normalVal.a >= 0.45) && (frag.normalVal.a <= 0.55)) { vec3 color = evalLightmappedColor( diff --git a/libraries/render-utils/src/directional_ambient_light_shadow.slf b/libraries/render-utils/src/directional_ambient_light_shadow.slf new file mode 100644 index 0000000000..1cb425c881 --- /dev/null +++ b/libraries/render-utils/src/directional_ambient_light_shadow.slf @@ -0,0 +1,51 @@ +<@include gpu/Config.slh@> +<$VERSION_HEADER$> +// Generated on <$_SCRIBE_DATE$> +// +// directional_light_shadow.frag +// fragment shader +// +// Created by Zach Pomerantz on 1/18/2016. +// Copyright 2016 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 +// + +<@include Shadow.slh@> +<@include DeferredBuffer.slh@> +<@include DeferredGlobalLight.slh@> + +<$declareEvalLightmappedColor()$> +<$declareEvalAmbientSphereGlobalColor()$> + +in vec2 _texCoord0; +out vec4 _fragColor; + +void main(void) { + DeferredTransform deferredTransform = getDeferredTransform(); + DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0); + + vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0); + float shadowAttenuation = evalShadowAttenuation(worldPos); + + if ((frag.normalVal.a >= 0.45) && (frag.normalVal.a <= 0.55)) { + vec3 color = evalLightmappedColor( + deferredTransform.viewInverse, + shadowAttenuation, + frag.normal, + frag.diffuse, + frag.specularVal.xyz); + _fragColor = vec4(color, 1.0); + } else { + vec3 color = evalAmbientSphereGlobalColor( + deferredTransform.viewInverse, + shadowAttenuation, + frag.position.xyz, + frag.normal, + frag.diffuse, + frag.specular, + frag.gloss); + _fragColor = vec4(color, frag.normalVal.a); + } +} diff --git a/libraries/render-utils/src/directional_light.slf b/libraries/render-utils/src/directional_light.slf index f057f9cc35..9318f07f5a 100644 --- a/libraries/render-utils/src/directional_light.slf +++ b/libraries/render-utils/src/directional_light.slf @@ -6,13 +6,12 @@ // fragment shader // // Created by Andrzej Kapolka on 9/3/14. -// Copyright 2014 High Fidelity, Inc. +// Copyright 2016 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 // -<@include Shadow.slh@> <@include DeferredBuffer.slh@> <@include DeferredGlobalLight.slh@> @@ -26,8 +25,7 @@ void main(void) { DeferredTransform deferredTransform = getDeferredTransform(); DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0); - vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0); - float shadowAttenuation = evalShadowAttenuation(worldPos); + float shadowAttenuation = 1.0; // Light mapped or not ? if ((frag.normalVal.a >= 0.45) && (frag.normalVal.a <= 0.55)) { diff --git a/libraries/render-utils/src/directional_light_shadow.slf b/libraries/render-utils/src/directional_light_shadow.slf new file mode 100644 index 0000000000..6c7c450bc5 --- /dev/null +++ b/libraries/render-utils/src/directional_light_shadow.slf @@ -0,0 +1,52 @@ +<@include gpu/Config.slh@> +<$VERSION_HEADER$> +// Generated on <$_SCRIBE_DATE$> +// +// directional_light_shadow.frag +// fragment shader +// +// Created by Zach Pomerantz on 1/18/2016. +// Copyright 2016 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 +// + +<@include Shadow.slh@> +<@include DeferredBuffer.slh@> +<@include DeferredGlobalLight.slh@> + +<$declareEvalLightmappedColor()$> +<$declareEvalAmbientGlobalColor()$> + +in vec2 _texCoord0; +out vec4 _fragColor; + +void main(void) { + DeferredTransform deferredTransform = getDeferredTransform(); + DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0); + + vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0); + float shadowAttenuation = evalShadowAttenuation(worldPos); + + // Light mapped or not ? + if ((frag.normalVal.a >= 0.45) && (frag.normalVal.a <= 0.55)) { + vec3 color = evalLightmappedColor( + deferredTransform.viewInverse, + shadowAttenuation, + frag.normal, + frag.diffuse, + frag.specularVal.xyz); + _fragColor = vec4(color, 1.0); + } else { + vec3 color = evalAmbientGlobalColor( + deferredTransform.viewInverse, + shadowAttenuation, + frag.position.xyz, + frag.normal, + frag.diffuse, + frag.specular, + frag.gloss); + _fragColor = vec4(color, frag.normalVal.a); + } +} diff --git a/libraries/render-utils/src/directional_skybox_light.slf b/libraries/render-utils/src/directional_skybox_light.slf index 871cb32337..d149a78a14 100755 --- a/libraries/render-utils/src/directional_skybox_light.slf +++ b/libraries/render-utils/src/directional_skybox_light.slf @@ -3,16 +3,15 @@ // Generated on <$_SCRIBE_DATE$> // // directional_light.frag - +// -<@include Shadow.slh@> <@include DeferredBuffer.slh@> <@include DeferredGlobalLight.slh@> @@ -26,8 +25,7 @@ void main(void) { DeferredTransform deferredTransform = getDeferredTransform(); DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0); - vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0); - float shadowAttenuation = evalShadowAttenuation(worldPos); + float shadowAttenuation = 1.0; // Light mapped or not ? if ((frag.normalVal.a >= 0.45) && (frag.normalVal.a <= 0.55)) { diff --git a/libraries/render-utils/src/directional_skybox_light_shadow.slf b/libraries/render-utils/src/directional_skybox_light_shadow.slf new file mode 100644 index 0000000000..1b7ef76035 --- /dev/null +++ b/libraries/render-utils/src/directional_skybox_light_shadow.slf @@ -0,0 +1,53 @@ +<@include gpu/Config.slh@> +<$VERSION_HEADER$> +// Generated on <$_SCRIBE_DATE$> +// +// directional_light_shadow.frag +// fragment shader +// +// Created by Zach Pomerantz on 1/18/2016. +// Copyright 2016 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 +//!> + +<@include Shadow.slh@> +<@include DeferredBuffer.slh@> +<@include DeferredGlobalLight.slh@> + +<$declareEvalLightmappedColor()$> +<$declareEvalSkyboxGlobalColor()$> + +in vec2 _texCoord0; +out vec4 _fragColor; + +void main(void) { + DeferredTransform deferredTransform = getDeferredTransform(); + DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0); + + vec4 worldPos = deferredTransform.viewInverse * vec4(frag.position.xyz, 1.0); + float shadowAttenuation = evalShadowAttenuation(worldPos); + + // Light mapped or not ? + if ((frag.normalVal.a >= 0.45) && (frag.normalVal.a <= 0.55)) { + vec3 color = evalLightmappedColor( + deferredTransform.viewInverse, + shadowAttenuation, + frag.normal, + frag.diffuse, + frag.specularVal.xyz); + _fragColor = vec4(color, 1.0); + } else { + vec3 color = evalSkyboxGlobalColor( + deferredTransform.viewInverse, + shadowAttenuation, + frag.position.xyz, + frag.normal, + frag.diffuse, + frag.specular, + frag.gloss); + + _fragColor = vec4(color, frag.normalVal.a); + } +}