Merge resolve

modules/skybrowser/include/screenspaceskytarget.h

@@ -17,6 +17,16 @@ namespace openspace {
     public:
         ScreenSpaceSkyTarget(const ghoul::Dictionary& dictionary);
         virtual ~ScreenSpaceSkyTarget() = default;
+
+        // from SSR
+        bool initializeGL() override;
+        bool isReady() const override;
+
+        void render() override;
+        void update() override;
+
+        void createShaders();
+
         glm::vec2 getScreenSpacePosition();
         glm::vec2 getAnglePosition();
        
@@ -27,11 +37,13 @@ namespace openspace {
         glm::vec2 getLowerLeftCornerScreenSpace();
         bool coordIsInsideCornersScreenSpace(glm::vec2 coord);
         
-          
         void bindTexture() override;
     private:
         std::unique_ptr<ghoul::opengl::Texture> _texture;
 
+        UniformCache(modelTransform, viewProj, texture, borderWidth, scale) _uniformCache;
+        GLuint _vertexArray = 0;
+        GLuint _vertexBuffer = 0;
     };
 }
 

modules/skybrowser/shaders/target_fs.glsl

@@ -1,6 +1,6 @@
 uniform sampler2D texture1;
-uniform float OcclusionDepth;
-uniform float Alpha;
+uniform float Scale;
+uniform float BorderWidth;
 
 in vec2 vs_st;
 in vec4 vs_position;
@@ -10,8 +10,17 @@ in vec4 vs_position;
 Fragment getFragment() {
     Fragment frag;
 
-    vec3 color = vec3(1.0);
-    frag.color = vec4(color, 1.0); 
+    vec2 bl = step(vec2(BorderWidth),1.0-vs_st);    // bottom-left line 
+    vec2 tr = step(vec2(BorderWidth),vs_st);        // top-right line 
 
+    vec3 border = vec3(tr.x * tr.y * bl.x * bl.y);
+
+    frag.color = texture(texture1, vs_st);
+
+    if(border == vec3(1.0)) {
+
+        frag.color.a = 0.0;
+    }
+    
     return frag;
-}
+}

modules/skybrowser/skybrowsermodule.cpp

@@ -100,7 +100,6 @@ SkyBrowserModule::SkyBrowserModule()
     addProperty(_testProperty);
     addProperty(_zoomFactor);
 
-
     global::callback::mousePosition->emplace_back(
         [&](double x, double y) {      
             glm::vec2 pos = glm::vec2(static_cast<float>(x), static_cast<float>(y));
@@ -377,7 +376,9 @@ ghoul::Dictionary SkyBrowserModule::createMessageForPausingWWTTime() const {
 }
 
 
+
 void SkyBrowserModule::initializeBrowser(ScreenSpaceSkyBrowser* skyBrowser, ScreenSpaceSkyTarget* skyTarget) {
+
     _skyBrowser = skyBrowser;
     _skyTarget = skyTarget;
 }
@@ -405,38 +406,26 @@ glm::dvec2 SkyBrowserModule::convertGalacticToCelestial(glm::dvec3 rGal) const {
     return glm::dvec2(glm::degrees(ra), glm::degrees(dec));
 }
 
-
-void SkyBrowserModule::checkIfTargetExist() {
-    ScreenSpaceSkyTarget* target = static_cast<ScreenSpaceSkyTarget*>(global::renderEngine->screenSpaceRenderable("ScreenSpaceTarget")); 
-
-    if (target) {
-        LINFO("Target is not null!");
-
-    }
-    LINFO("Target has been checked!");
-}
-
 void SkyBrowserModule::createTarget() {
 
     using namespace std::string_literals;
 
-    // Create target test
     std::string node = "{"
         "Type = 'ScreenSpaceSkyTarget',"
         "Identifier = 'ScreenSpaceTarget',"
         "Name = 'Screen Space Target',"
-        "FaceCamera = false"
+        "FaceCamera = false,"
+        "Scale = 0.04,"
         "}";
 
     openspace::global::scriptEngine->queueScript(
         "openspace.addScreenSpaceRenderable(" + node + ")",
         scripting::ScriptEngine::RemoteScripting::Yes
     );
-
+    
 }
 
 
-
 /*
 std::vector<documentation::Documentation> SkyBrowserModule::documentations() const {
     return {

modules/skybrowser/skybrowsermodule.h

@@ -53,7 +53,6 @@ public:
 
     // target
     void createTarget();
-    void checkIfTargetExist();
 
     ghoul::Dictionary createMessageForMovingWWTCamera(const glm::dvec2 celestCoords, const float fov, const bool moveInstantly = true) const;
     ghoul::Dictionary createMessageForPausingWWTTime() const;

modules/skybrowser/skybrowsermodule_lua.inl

@@ -59,7 +59,6 @@ namespace openspace::skybrowser::luascriptfunctions {
         ScreenSpaceSkyTarget* target = dynamic_cast<ScreenSpaceSkyTarget*>(global::renderEngine->screenSpaceRenderable("ScreenSpaceTarget"));
         module->initializeBrowser(browser, target);     
         module->skyBrowser()->translate(glm::vec3(-0.8, -0.4, 0.0));
-        module->checkIfTargetExist();
 
         return 1;
     }
@@ -89,11 +88,7 @@ namespace openspace::skybrowser::luascriptfunctions {
         openspace::global::scriptEngine->queueScript(
             "openspace.addScreenSpaceRenderable(" + node + ")",
             scripting::ScriptEngine::RemoteScripting::Yes
-        );
-
-        //test create target
-        module->createTarget();
-        
+        );    
         return 1;
     }
     

modules/skybrowser/src/screenspaceskytarget.cpp

@@ -13,7 +13,7 @@
 #include <ghoul/logging/logmanager.h>
 
 #include <openspace/scripting/scriptengine.h>
-
+#include <openspace/engine/windowdelegate.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/texture.h>
@@ -27,11 +27,12 @@
 #include <openspace/engine/windowdelegate.h>
 #include <glm/gtx/matrix_decompose.hpp>
 
+
 namespace {
     constexpr const char* _loggerCat = "ScreenSpaceSkyTarget";
 
-    constexpr const std::array<const char*, 4> UniformNames = {
-    "Alpha", "ModelTransform", "ViewProjectionMatrix", "texture1"
+    constexpr const std::array<const char*, 5> UniformNames = {
+    "ModelTransform", "ViewProjectionMatrix", "texture1", "BorderWidth", "Scale"
     };
 
 } //namespace
@@ -74,6 +75,84 @@ namespace openspace {
         }
     }
 
+    bool ScreenSpaceSkyTarget::isReady() const {
+        return _shader != nullptr;
+    }
+
+    bool ScreenSpaceSkyTarget::initializeGL() {
+
+        glGenVertexArrays(1, &_vertexArray);
+        glGenBuffers(1, &_vertexBuffer);
+
+        std::unique_ptr<ghoul::opengl::Texture> texture = ghoul::io::TextureReader::ref().loadTexture(absPath("${MODULE_SKYBROWSER}/square.png"));
+   
+
+        if (texture) {
+            // Images don't need to start on 4-byte boundaries, for example if the
+            // image is only RGB
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+            texture->uploadTexture();
+            texture->setFilter(ghoul::opengl::Texture::FilterMode::LinearMipMap);
+            texture->purgeFromRAM();
+
+            _texture = std::move(texture);
+            _objectSize = _texture->dimensions();
+        }
+    
+        createShaders();
+
+        return isReady();
+    }
+
+    void ScreenSpaceSkyTarget::createShaders() {
+
+        _shader = global::renderEngine->buildRenderProgram(
+            "ScreenSpaceProgram",
+            absPath("${MODULE_SKYBROWSER}/shaders/target_vs.glsl"),
+            absPath("${MODULE_SKYBROWSER}/shaders/target_fs.glsl")
+        );
+
+        ghoul::opengl::updateUniformLocations(*_shader, _uniformCache, UniformNames);
+
+    }
+
+    void ScreenSpaceSkyTarget::render() {
+
+        glDisable(GL_CULL_FACE);
+       
+        glm::mat4 modelTransform = globalRotationMatrix() * translationMatrix() * localRotationMatrix() * scaleMatrix();
+        float borderWidth = 0.002f;
+        
+        _shader->activate();
+
+        _shader->setUniform(_uniformCache.borderWidth, borderWidth);
+        _shader->setUniform(_uniformCache.modelTransform, modelTransform);
+
+        _shader->setUniform(
+            _uniformCache.viewProj,
+            global::renderEngine->scene()->camera()->viewProjectionMatrix()
+        );
+
+        ghoul::opengl::TextureUnit unit;
+        unit.activate();
+        bindTexture();
+        _shader->setUniform(_uniformCache.texture, unit);
+
+        glBindVertexArray(rendering::helper::vertexObjects.square.vao);
+        glDrawArrays(GL_TRIANGLES, 0, 6);
+
+        glEnable(GL_CULL_FACE);
+
+        _shader->deactivate();
+        unbindTexture();
+    }
+
+    void ScreenSpaceSkyTarget::update() {
+
+
+    }
+
     void ScreenSpaceSkyTarget::translate(glm::vec2 translation, glm::vec2 position) {
         _cartesianPosition = glm::translate(glm::mat4(1.f), glm::vec3(translation, 0.0f)) * glm::vec4(position, _cartesianPosition.value().z, 1.0f);
     }
@@ -105,5 +184,4 @@ namespace openspace {
         bool moreThanLowerLeft = coord.x > getLowerLeftCornerScreenSpace().x && coord.y > getLowerLeftCornerScreenSpace().y;
         return  lessThanUpperRight && moreThanLowerLeft;
     }
-  
 }