Feature/model shader (#1723)

* Add support for RenderableModel to take custom shader code
 * Added example to highlight usage

data/assets/examples/modelshader/model_fs.glsl

@@ -0,0 +1,75 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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.                                         *
+ ****************************************************************************************/
+
+#include "fragment.glsl"
+
+in vec2 vs_st;
+in vec3 vs_normalViewSpace;
+in vec4 vs_positionCameraSpace;
+in float vs_screenSpaceDepth;
+in mat3 TBN;
+
+uniform float ambientIntensity = 0.2;
+uniform float diffuseIntensity = 1.0;
+uniform float specularIntensity = 1.0;
+
+uniform bool performShading = true;
+uniform bool use_forced_color = false;
+uniform bool has_texture_diffuse;
+uniform bool has_texture_normal;
+uniform bool has_texture_specular;
+uniform bool has_color_specular;
+
+uniform bool opacityBlending = false;
+
+uniform sampler2D texture_diffuse;
+uniform sampler2D texture_normal;
+uniform sampler2D texture_specular;
+
+uniform vec3 color_diffuse;
+uniform vec3 color_specular;
+
+uniform int nLightSources;
+uniform vec3 lightDirectionsViewSpace[8];
+uniform float lightIntensities[8];
+
+uniform float opacity = 1.0;
+
+Fragment getFragment() {
+  Fragment frag;
+
+  if (has_texture_normal) {
+    vec3 normalAlbedo = texture(texture_normal, vs_st).rgb;
+    normalAlbedo = normalize(normalAlbedo * 2.0 - 1.0);
+    frag.color.rgb = normalize(TBN * normalAlbedo);
+  }
+  else {
+    frag.color.rgb = normalize(vs_normalViewSpace);
+  }
+  frag.color.a = 1.0;
+  frag.gPosition      = vs_positionCameraSpace;
+  frag.gNormal        = vec4(vs_normalViewSpace, 0.0);
+  frag.disableLDR2HDR = true;
+  return frag;
+}

data/assets/examples/modelshader/model_vs.glsl

@@ -0,0 +1,68 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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.                                         *
+ ****************************************************************************************/
+
+#version __CONTEXT__
+
+#include "PowerScaling/powerScaling_vs.hglsl"
+
+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 vec3 in_tangent;
+
+out vec2 vs_st;
+out vec3 vs_normalViewSpace;
+out float vs_screenSpaceDepth;
+out vec4 vs_positionCameraSpace;
+out mat3 TBN;
+
+uniform mat4 modelViewTransform;
+uniform mat4 projectionTransform;
+uniform mat4 normalTransform;
+uniform mat4 meshTransform;
+uniform mat4 meshNormalTransform;
+
+void main() {
+  vs_positionCameraSpace = modelViewTransform * (meshTransform * in_position);
+  vec4 positionClipSpace = projectionTransform * vs_positionCameraSpace;
+  vec4 positionScreenSpace = z_normalization(positionClipSpace);
+
+  gl_Position = positionScreenSpace;
+  vs_st = in_st;
+  vs_screenSpaceDepth = positionScreenSpace.w;
+    
+  vs_normalViewSpace = normalize(mat3(normalTransform) * (mat3(meshNormalTransform) * in_normal));
+
+	// TBN matrix for normal mapping
+	vec3 T = normalize(mat3(normalTransform) * (mat3(meshNormalTransform) * in_tangent));
+	vec3 N = normalize(mat3(normalTransform) * (mat3(meshNormalTransform) * in_normal));
+
+	// Re-orthogonalize T with respect to N
+	T = normalize(T - dot(T, N) * N);
+
+	// Retrieve perpendicular vector B with cross product of T and N
+	vec3 B = normalize(cross(N, T));
+
+	TBN = mat3(T, B, N);
+}

data/assets/examples/modelshader/modelshader.asset

@@ -0,0 +1,45 @@
+local assetHelper = asset.require('util/asset_helper')
+local sunTransforms = asset.require('scene/solarsystem/sun/transforms')
+local transforms = asset.require('scene/solarsystem/planets/earth/transforms')
+
+local model = asset.syncedResource({
+  Name = "Animated Box",
+  Type = "HttpSynchronization",
+  Identifier = "animated_box",
+  Version = 1
+})
+
+local model = {
+  Identifier = "modelshader",
+  Parent = transforms.EarthCenter.Identifier,
+  Transform = {
+    Translation = {
+      Type = "StaticTranslation",
+      Position = { 11E7, 0.0, 0.0 }
+    }
+  },
+  Renderable = {
+    Type = "RenderableModel",
+    GeometryFile = model .. "/BoxAnimated.glb",
+    ModelScale = 3E7,
+    LightSources = {
+      {
+        Type = "SceneGraphLightSource",
+        Identifier = "Sun",
+        Node = sunTransforms.SolarSystemBarycenter.Identifier,
+        Intensity = 1.0
+      }
+    },
+    PerformShading = true,
+    DisableFaceCulling = true,
+    VertexShader = asset.localResource("model_vs.glsl"),
+    FragmentShader = asset.localResource("model_fs.glsl"),
+  },
+  GUI = {
+    Name = "Model Shader",
+    Path = "/Example",
+    Description = "Simple box model with a custom shader",
+  }
+}
+
+assetHelper.registerSceneGraphNodesAndExport(asset, { model })

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
@@ -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/shaders/model_vs.glsl

@@ -44,15 +44,15 @@ uniform mat4 meshTransform;
 uniform mat4 meshNormalTransform;
 
 void main() {
-    vs_positionCameraSpace = modelViewTransform * (meshTransform * in_position);
-    vec4 positionClipSpace = projectionTransform * vs_positionCameraSpace;
-    vec4 positionScreenSpace = z_normalization(positionClipSpace);
+  vs_positionCameraSpace = modelViewTransform * (meshTransform * in_position);
+  vec4 positionClipSpace = projectionTransform * vs_positionCameraSpace;
+  vec4 positionScreenSpace = z_normalization(positionClipSpace);
 
-    gl_Position = positionScreenSpace;
-    vs_st = in_st;
-    vs_screenSpaceDepth = positionScreenSpace.w;
+  gl_Position = positionScreenSpace;
+  vs_st = in_st;
+  vs_screenSpaceDepth = positionScreenSpace.w;
     
-    vs_normalViewSpace = normalize(mat3(normalTransform) * (mat3(meshNormalTransform) * in_normal));
+  vs_normalViewSpace = normalize(mat3(normalTransform) * (mat3(meshNormalTransform) * in_normal));
 
 	// TBN matrix for normal mapping
 	vec3 T = normalize(mat3(normalTransform) * (mat3(meshNormalTransform) * in_tangent));