Changed default moon scene for a total lunar eclipse.

data/scene/default-moon.scene

@@ -19,8 +19,16 @@ function preInitialization()
 
      --   6:20 -> 23:20 day before in UTC
     ]]--
-    openspace.time.setTime("2016-03-08T23:00:00")
-    openspace.time.setDeltaTime(500.0)
+    --openspace.time.setTime("2016-03-08T22:45:00")
+
+
+    -- Total Lunar Eclipse Jan 31, 2018 at 10:51:13 UTC
+    -- Regions seeing, at least, some parts of the eclipse: North/East Europe,
+    -- Asia, Australia, North/East Africa, North America, North/East South America,
+    -- Pacific, Atlantic, Indian Ocean, Arctic, Antarctica.
+    openspace.time.setTime("2018-01-31T10:30:00")
+
+    openspace.time.setDeltaTime(200.0)
     dofile(openspace.absPath('${SCRIPTS}/bind_keys.lua'))
 end
 
@@ -48,7 +56,8 @@ return {
     ScenePath = ".",
     CommonFolder = "common",
     Camera = {
-        Focus = "Earth",
+        --Focus = "Earth",
+        Focus = "Moon",
         Position = {1, 0, 0, 5},
     },
     Modules = {

data/scene/moon/moon.mod

@@ -12,6 +12,16 @@ return {
                 Radius = { 1.737, 6},
                 Segments = 100
             },
+            Shadow_Group = {
+                Source1 = {
+                    Name = "Sun",
+                    Radius = {696.3, 6}
+                },
+                Caster1 = { 
+                    Name = "Earth",
+                    Radius = {6.371, 6}
+                },
+            },
             Textures = {
                 Type = "simple",
                 Color = "textures/Moon16K.dds",

modules/base/rendering/renderableplanet.cpp

@@ -137,6 +137,7 @@ RenderablePlanet::RenderablePlanet(const ghoul::Dictionary& dictionary)
     // Shadow data:
     ghoul::Dictionary shadowDictionary;
     success = dictionary.getValue(keyShadowGroup, shadowDictionary);
+    bool disableShadows = false;
     if (success) {
         std::vector< std::pair<std::string, float > > sourceArray;
         unsigned int sourceCounter = 1;
@@ -151,58 +152,60 @@ RenderablePlanet::RenderablePlanet(const ghoul::Dictionary& dictionary)
                 ss << keyShadowSource << sourceCounter << ".Radius";
                 success = shadowDictionary.getValue(ss.str(), sourceRadius);
                 if (success) {
-                    sourceArray.push_back(std::pair< std::string, float>(sourceName, sourceRadius[0] * glm::pow(10, sourceRadius[1])));
+                    sourceArray.push_back(std::pair< std::string, float>(
+                        sourceName, sourceRadius[0] * glm::pow(10, sourceRadius[1])));
                 }
                 else {
-                    // TODO: handle not success
-                    ;
+                    LWARNING("No Radius value expecified for Shadow Source Name " 
+                        << sourceName << " from " << name 
+                        << " planet.\nDisabling shadows for this planet.");
+                    disableShadows = true;
+                    break;
                 }
             }
-            else {
-                // TODO: handle not success
-                ;
-            }
-
             sourceCounter++;
         }
 
-        success = true;
-        
-        std::vector< std::pair<std::string, float > > casterArray;
-        unsigned int casterCounter = 1;
-        while (success) {
-            std::string casterName;
-            std::stringstream ss;
-            ss << keyShadowCaster << casterCounter << ".Name";
-            success = shadowDictionary.getValue(ss.str(), casterName);            
-            if (success) {
-                glm::vec2 casterRadius;
-                ss.str(std::string());
-                ss << keyShadowCaster << casterCounter << ".Radius";
-                success = shadowDictionary.getValue(ss.str(), casterRadius);
+        if (!disableShadows && !sourceArray.empty()) {
+            success = true;
+            std::vector< std::pair<std::string, float > > casterArray;
+            unsigned int casterCounter = 1;
+            while (success) {
+                std::string casterName;
+                std::stringstream ss;
+                ss << keyShadowCaster << casterCounter << ".Name";
+                success = shadowDictionary.getValue(ss.str(), casterName);
                 if (success) {
-                    casterArray.push_back(std::pair< std::string, float>(casterName, casterRadius[0] * glm::pow(10, casterRadius[1])));
+                    glm::vec2 casterRadius;
+                    ss.str(std::string());
+                    ss << keyShadowCaster << casterCounter << ".Radius";
+                    success = shadowDictionary.getValue(ss.str(), casterRadius);
+                    if (success) {
+                        casterArray.push_back(std::pair< std::string, float>(
+                            casterName, casterRadius[0] * glm::pow(10, casterRadius[1])));
+                    }
+                    else {
+                        LWARNING("No Radius value expecified for Shadow Caster Name "
+                            << casterName << " from " << name
+                            << " planet.\nDisabling shadows for this planet.");
+                        disableShadows = true;
+                        break;
+                    }
                 }
-                else {
-                    // TODO: handle not success
-                    ;
-                }
-            }
-            else {
-                // TODO: handle not success
-                ;
+
+                casterCounter++;
             }
 
-            casterCounter++;
+            if (!disableShadows && (!sourceArray.empty() && !casterArray.empty())) {
+                for (const auto & source : sourceArray)
+                    for (const auto & caster : casterArray) {
+                        ShadowConf sc;
+                        sc.source = source;
+                        sc.caster = caster;
+                        _shadowConfArray.push_back(sc);
+                    }
+            }
         }
-
-        for ( const auto & source : sourceArray )
-            for (const auto & caster : casterArray) {
-                ShadowConf sc;
-                sc.source = source;
-                sc.caster = caster;
-                _shadowConfArray.push_back(sc);
-            }
     }
 
 }

modules/base/shaders/shadow_fs.glsl

@@ -0,0 +1,129 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * OpenSpace                                                                             *
+ *                                                                                       *
+ * Copyright (c) 2014                                                                    *
+ *                                                                                       *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
+ * software and associated documentation files (the "Software"), to deal in the Software *
+ * without restriction, including without limitation the rights to use, copy, modify,    *
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
+ * permit persons to whom the Software is furnished to do so, subject to the following   *
+ * conditions:                                                                           *
+ *                                                                                       *
+ * The above copyright notice and this permission notice shall be included in all copies *
+ * or substantial portions of the Software.                                              *
+ *                                                                                       *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
+ ****************************************************************************************/
+
+const uint numberOfShadows = 1;
+
+struct ShadowRenderingStruct {
+        float xu, xp;
+        float rs, rc;
+        vec3 sourceCasterVec;
+        vec3 casterPositionVec;
+        bool isShadowing;
+};
+
+uniform ShadowRenderingStruct shadowDataArray[numberOfShadows];
+
+uniform vec4 campos;
+uniform vec4 objpos;
+
+uniform vec3 sun_pos;
+
+uniform bool _performShading = true;
+uniform float transparency;
+uniform int shadows;
+
+uniform float time;
+uniform sampler2D texture1;
+
+in vec2 vs_st;
+in vec4 vs_normal;
+in vec4 vs_position;
+in vec4 vs_posWorld;
+
+#include "PowerScaling/powerScaling_fs.hglsl"
+#include "fragment.glsl"
+
+vec4 butterworthFunc(const float d, const float r, const float n) {
+    return vec4(vec3(sqrt(r/(r + pow(d, 2*n)))), 1.0);    
+}
+
+vec4 calcShadow(const ShadowRenderingStruct shadowInfoArray[numberOfShadows], const vec3 position) {
+    if (shadowInfoArray[0].isShadowing) {
+        vec3 pc = shadowInfoArray[0].casterPositionVec - position;
+        vec3 sc_norm = normalize(shadowInfoArray[0].sourceCasterVec); // we can pass this normalized to the shader
+        vec3 pc_proj = dot(pc, sc_norm) * sc_norm;
+        vec3 d = pc - pc_proj;
+        
+        float length_d = length(d);
+        float length_pc_proj = length(pc_proj);
+        
+        float r_p_pi = shadowInfoArray[0].rc * (length_pc_proj + shadowInfoArray[0].xp) / shadowInfoArray[0].xp;
+        
+        //float r_u_pi = shadowInfoArray[0].rc * (length_pc_proj + shadowInfoArray[0].xu) / shadowInfoArray[0].xu;
+        float r_u_pi = shadowInfoArray[0].rc * (shadowInfoArray[0].xu - length_pc_proj) / shadowInfoArray[0].xu;
+        
+        if ( length_d < r_u_pi ) { // umbra
+            return vec4(0.0, 0.0, 0.0, 1.0);
+            //return vec4(1.0, 0.0, 0.0, 1.0);
+            //return butterworthFunc(length_d, r_u_pi, 4.0);
+        }
+        else if ( length_d < r_p_pi ) {// penumbra
+            return vec4(0.5, 0.5, 0.5, 1.0);
+            //return vec4(0.0, 1.0, 0.0, 1.0);
+            //return vec4(vec3(length_d/r_p_pi), 1.0);
+        }
+    }
+     
+    return vec4(1.0);
+}
+
+Fragment getFragment() {
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
+    vec4 diffuse = texture(texture1, vs_st);
+
+    Fragment frag;
+    if (_performShading) {
+        // directional lighting
+        vec3 origin = vec3(0.0);
+        vec4 spec = vec4(0.0);
+        
+        vec3 n = normalize(vs_normal.xyz);
+        //vec3 e = normalize(camdir);
+        vec3 l_pos = vec3(sun_pos); // sun.
+        vec3 l_dir = normalize(l_pos-objpos.xyz);
+        float intensity = min(max(5*dot(n,l_dir), 0.0), 1);
+        float darkSide  = min(max(5*dot(n,-l_dir), 0.0), 1);
+        
+        float shine = 0.0001;
+
+        vec4 specular = vec4(0.5);
+        vec4 ambient = vec4(0.0,0.0,0.0,transparency);
+        
+        vec4 daytex = max(intensity * diffuse, ambient);
+        //vec4 mixtex = mix(diffuse, diffuse2,  (1+dot(n,-l_dir))/2);    
+        
+        //diffuse = (daytex*2 + mixtex)/3;
+        diffuse = daytex;
+        
+        diffuse *= calcShadow(shadowDataArray, vs_posWorld.xyz);
+    }
+    
+    diffuse[3] = transparency;
+    frag.color = diffuse;
+    frag.depth = depth;
+
+    return frag;
+}
+

modules/base/shaders/shadow_vs.glsl

@@ -0,0 +1,68 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * OpenSpace                                                                             *
+ *                                                                                       *
+ * Copyright (c) 2014                                                                    *
+ *                                                                                       *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
+ * software and associated documentation files (the "Software"), to deal in the Software *
+ * without restriction, including without limitation the rights to use, copy, modify,    *
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
+ * permit persons to whom the Software is furnished to do so, subject to the following   *
+ * conditions:                                                                           *
+ *                                                                                       *
+ * The above copyright notice and this permission notice shall be included in all copies *
+ * or substantial portions of the Software.                                              *
+ *                                                                                       *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
+ ****************************************************************************************/
+
+#version __CONTEXT__
+
+uniform mat4 ViewProjection;
+uniform mat4 ModelTransform;
+
+layout(location = 0) in vec4 in_position;
+layout(location = 1) in vec2 in_st;
+layout(location = 2) in vec3 in_normal;
+//layout(location = 3) in vec2 in_nightTex;
+
+
+out vec2 vs_st;
+out vec4 vs_normal;
+out vec4 vs_position;
+out vec4 vs_posWorld;
+out float s;
+
+#include "PowerScaling/powerScaling_vs.hglsl"
+
+void main()
+{
+    // set variables
+    vs_st = in_st;
+    vs_position = in_position;
+    vec4 tmp = in_position;
+
+    // this is wrong for the normal. The normal transform is the transposed inverse of the model transform
+    vs_normal = normalize(ModelTransform * vec4(in_normal,0));
+
+    // The things is not in world coordinates, they are in
+    // regular view/eye coordinates.
+    vec4 position = pscTransform(tmp, ModelTransform);
+
+    vec3 local_vertex_pos = mat3(ModelTransform) * in_position.xyz;
+    vec4 vP = psc_addition(vec4(local_vertex_pos,in_position.w),objpos);
+    vec4 conv = vec4(vP.xyz * pow(10,vP.w), 1.0);
+    vs_posWorld = conv;
+    
+    vs_position = tmp;
+    // Now is transforming from view position to SGCT projection
+    // coordinates.
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
+}