Merge branch 'master' into thesis/2020/radiation

modules/base/rendering/renderablemodel.cpp

@@ -249,6 +249,14 @@ namespace {
 
         // [[codegen::verbatim(EnableOpacityBlendingInfo.description)]]
         std::optional<bool> enableOpacityBlending;
+
+        // The path to the vertex shader program that is used instead of the default
+        // shader.
+        std::optional<std::filesystem::path> vertexShader;
+
+        // The path to the fragment shader program that is used instead of the default
+        // shader.
+        std::optional<std::filesystem::path> fragmentShader;
     };
 #include "renderablemodel_codegen.cpp"
 } // namespace
@@ -335,7 +343,7 @@ RenderableModel::RenderableModel(const ghoul::Dictionary& dictionary)
                     distanceUnit = DistanceUnit::Kilometer;
                     break;
 
-                // Weired units
+                // Weird units
                 case Parameters::ScaleUnit::Thou:
                     distanceUnit = DistanceUnit::Thou;
                     break;
@@ -472,6 +480,13 @@ RenderableModel::RenderableModel(const ghoul::Dictionary& dictionary)
     _disableDepthTest = p.disableDepthTest.value_or(_disableDepthTest);
     _disableFaceCulling = p.disableFaceCulling.value_or(_disableFaceCulling);
 
+    if (p.vertexShader.has_value()) {
+        _vertexShaderPath = p.vertexShader->string();
+    }
+    if (p.fragmentShader.has_value()) {
+        _fragmentShaderPath = p.fragmentShader->string();
+    }
+
     if (p.lightSources.has_value()) {
         std::vector<ghoul::Dictionary> lightsources = *p.lightSources;
 
@@ -560,16 +575,33 @@ void RenderableModel::initialize() {
 void RenderableModel::initializeGL() {
     ZoneScoped
 
+    std::string program = ProgramName;
+    if (!_vertexShaderPath.empty()) {
+        program += "|vs=" + _vertexShaderPath;
+    }
+    if (!_fragmentShaderPath.empty()) {
+        program += "|fs=" + _fragmentShaderPath;
+    }
     _program = BaseModule::ProgramObjectManager.request(
-        ProgramName,
-        []() -> std::unique_ptr<ghoul::opengl::ProgramObject> {
-            return global::renderEngine->buildRenderProgram(
-                ProgramName,
-                absPath("${MODULE_BASE}/shaders/model_vs.glsl"),
-                absPath("${MODULE_BASE}/shaders/model_fs.glsl")
-            );
+        program,
+        [&]() -> std::unique_ptr<ghoul::opengl::ProgramObject> {
+            std::filesystem::path vs =
+                _vertexShaderPath.empty() ?
+                absPath("${MODULE_BASE}/shaders/model_vs.glsl") :
+                _vertexShaderPath;
+            std::filesystem::path fs =
+                _fragmentShaderPath.empty() ?
+                absPath("${MODULE_BASE}/shaders/model_fs.glsl") :
+                _fragmentShaderPath;
+
+            return global::renderEngine->buildRenderProgram(ProgramName, vs, fs);
         }
     );
+    // We don't really know what kind of shader the user provides us with, so we can't
+    // make the assumption that we are going to use all uniforms
+    _program->setIgnoreUniformLocationError(
+        ghoul::opengl::ProgramObject::IgnoreError::Yes
+    );
 
     ghoul::opengl::updateUniformLocations(*_program, _uniformCache, UniformNames);
 
@@ -581,8 +613,15 @@ void RenderableModel::deinitializeGL() {
     _geometry->deinitialize();
     _geometry.reset();
 
+    std::string program = ProgramName;
+    if (!_vertexShaderPath.empty()) {
+        program += "|vs=" + _vertexShaderPath;
+    }
+    if (!_fragmentShaderPath.empty()) {
+        program += "|fs=" + _fragmentShaderPath;
+    }
     BaseModule::ProgramObjectManager.release(
-        ProgramName,
+        program,
         [](ghoul::opengl::ProgramObject* p) {
             global::renderEngine->removeRenderProgram(p);
         }

modules/base/rendering/renderablemodel.h

@@ -101,6 +101,8 @@ private:
     properties::BoolProperty _enableOpacityBlending;
     properties::OptionProperty _blendingFuncOption;
 
+    std::string _vertexShaderPath;
+    std::string _fragmentShaderPath;
     ghoul::opengl::ProgramObject* _program = nullptr;
     UniformCache(opacity, nLightSources, lightDirectionsViewSpace, lightIntensities,
         modelViewTransform, normalTransform, projectionTransform,

modules/base/rendering/renderablenodeline.cpp

@@ -27,8 +27,8 @@
 #include <modules/base/basemodule.h>
 #include <openspace/documentation/verifier.h>
 #include <openspace/engine/globals.h>
-#include <openspace/interaction/navigationhandler.h>
-#include <openspace/interaction/orbitalnavigator.h>
+#include <openspace/navigation/navigationhandler.h>
+#include <openspace/navigation/orbitalnavigator.h>
 #include <openspace/rendering/renderengine.h>
 #include <openspace/scene/scene.h>
 #include <openspace/scene/translation.h>

modules/base/rendering/renderabletrail.cpp

@@ -338,7 +338,6 @@ void RenderableTrail::internalRender(bool renderLines, bool renderPoints,
     _programObject->setUniform(_uniformCache.nVertices, nVertices);
 
 #if !defined(__APPLE__)
-    glm::ivec2 resolution = global::renderEngine->renderingResolution();
     GLint viewport[4];
     global::renderEngine->openglStateCache().viewport(viewport);
     _programObject->setUniform(

modules/base/rendering/screenspacedashboard.cpp

@@ -54,79 +54,10 @@ namespace {
 #include "screenspacedashboard_codegen.cpp"
 } // namespace
 
+#include "screenspacedashboard_lua.inl"
+
 namespace openspace {
 
-namespace luascriptfunctions {
-
-/**
-* \ingroup LuaScripts
-* addDashboardItemToScreenSpace(string, table):
-*/
-int addDashboardItemToScreenSpace(lua_State* L) {
-    ghoul::lua::checkArgumentsAndThrow(L, 2, "lua::addDashboardItemToScreenSpace");
-
-    const std::string& name = ghoul::lua::value<std::string>(L, 1);
-    const int type = lua_type(L, 2);
-    if (type != LUA_TTABLE) {
-        return ghoul::lua::luaError(L, "Expected argument of type 'table'");
-    }
-
-    ghoul::Dictionary d;
-    try {
-        ghoul::lua::luaDictionaryFromState(L, d);
-    }
-    catch (const ghoul::lua::LuaFormatException& e) {
-        LERRORC("addDashboardItem", e.what());
-        return 0;
-    }
-
-    ScreenSpaceRenderable* ssr = global::renderEngine->screenSpaceRenderable(name);
-
-    if (!ssr) {
-        return ghoul::lua::luaError(L, "Provided name is not a ScreenSpace item");
-    }
-
-    ScreenSpaceDashboard* dash = dynamic_cast<ScreenSpaceDashboard*>(ssr);
-    if (!dash) {
-        return ghoul::lua::luaError(
-            L,
-            "Provided name is a ScreenSpace item but not a dashboard"
-        );
-    }
-
-    dash->dashboard().addDashboardItem(DashboardItem::createFromDictionary(d));
-
-    lua_settop(L, 0);
-    return 0;
-}
-
-/**
-* \ingroup LuaScripts
-* removeDashboardItemsFromScreenSpace(string):
-*/
-int removeDashboardItemsFromScreenSpace(lua_State* L) {
-    ghoul::lua::checkArgumentsAndThrow(L, 1, "lua::removeDashboardItemsFromScreenSpace");
-
-    const std::string& name = ghoul::lua::value<std::string>(L, 1);
-    ScreenSpaceRenderable* ssr = global::renderEngine->screenSpaceRenderable(name);
-
-    if (!ssr) {
-        return ghoul::lua::luaError(L, "Provided name is not a ScreenSpace item");
-    }
-
-    ScreenSpaceDashboard* dash = dynamic_cast<ScreenSpaceDashboard*>(ssr);
-    if (!dash) {
-        return ghoul::lua::luaError(
-            L,
-            "Provided name is a ScreenSpace item but not a dashboard"
-        );
-    }
-
-    dash->dashboard().clearDashboardItems();
-    return 0;
-}
-} // namespace luascriptfunctions
-
 documentation::Documentation ScreenSpaceDashboard::Documentation() {
     return codegen::doc<Parameters>("base_screenspace_dashboard");
 }

modules/base/rendering/screenspacedashboard_lua.inl

@@ -0,0 +1,77 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * OpenSpace                                                                             *
+ *                                                                                       *
+ * Copyright (c) 2014-2021                                                               *
+ *                                                                                       *
+ * 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.                                         *
+ ****************************************************************************************/
+
+namespace openspace::luascriptfunctions {
+
+/**
+ * \ingroup LuaScripts
+ * addDashboardItemToScreenSpace(string, table):
+ */
+int addDashboardItemToScreenSpace(lua_State* L) {
+    ghoul::lua::checkArgumentsAndThrow(L, 2, "lua::addDashboardItemToScreenSpace");
+    auto [name, d] = ghoul::lua::values<std::string, ghoul::Dictionary>(L);
+
+    ScreenSpaceRenderable* ssr = global::renderEngine->screenSpaceRenderable(name);
+    if (!ssr) {
+        return ghoul::lua::luaError(L, "Provided name is not a ScreenSpace item");
+    }
+
+    ScreenSpaceDashboard* dash = dynamic_cast<ScreenSpaceDashboard*>(ssr);
+    if (!dash) {
+        return ghoul::lua::luaError(
+            L,
+            "Provided name is a ScreenSpace item but not a dashboard"
+        );
+    }
+
+    dash->dashboard().addDashboardItem(DashboardItem::createFromDictionary(d));
+    return 0;
+}
+
+/**
+ * \ingroup LuaScripts
+ * removeDashboardItemsFromScreenSpace(string):
+ */
+int removeDashboardItemsFromScreenSpace(lua_State* L) {
+    ghoul::lua::checkArgumentsAndThrow(L, 1, "lua::removeDashboardItemsFromScreenSpace");
+    const std::string name = ghoul::lua::value<std::string>(L);
+
+    ScreenSpaceRenderable* ssr = global::renderEngine->screenSpaceRenderable(name);
+    if (!ssr) {
+        return ghoul::lua::luaError(L, "Provided name is not a ScreenSpace item");
+    }
+
+    ScreenSpaceDashboard* dash = dynamic_cast<ScreenSpaceDashboard*>(ssr);
+    if (!dash) {
+        return ghoul::lua::luaError(
+            L,
+            "Provided name is a ScreenSpace item but not a dashboard"
+        );
+    }
+
+    dash->dashboard().clearDashboardItems();
+    return 0;
+}
+
+} // namespace openspace::luascriptfunctions