Load browser and target as assets

data/assets/skyBrowser.asset

@@ -0,0 +1,12 @@
+local assetHelper = asset.require('util/asset_helper')
+
+     local spec = {
+         Type = "ScreenSpaceSkyBrowser",
+         Identifier = "SkyBrowser1",
+         Name = "SkyBrowser",
+         Url = "http://localhost:8000/",
+         FaceCamera = false,
+         TargetID = "SkyTarget1"
+     };
+
+assetHelper.registerScreenSpaceRenderables(asset, { spec })

data/assets/skyTarget.asset

@@ -0,0 +1,11 @@
+local assetHelper = asset.require('util/asset_helper')
+
+     local spec = {
+         Type = "ScreenSpaceSkyTarget",
+         Identifier = "SkyTarget1",
+         Name = "Target",
+         FaceCamera = false,
+         BrowserID = "SkyBrowser1"
+     };
+
+assetHelper.registerScreenSpaceRenderables(asset, { spec })

modules/skybrowser/data/skyBrowser.asset

@@ -0,0 +1,11 @@
+local assetHelper = asset.require('util/asset_helper')
+
+     local spec = {
+         Type = "ScreenSpaceSkyBrowser",
+         Identifier = "SkyBrowser1",
+         Name = "SkyBrowser",
+         Url = "http://localhost:8000/",
+         FaceCamera = false
+     };
+
+assetHelper.registerScreenSpaceRenderables(asset, { spec })

modules/skybrowser/data/skyTarget.asset

@@ -0,0 +1,10 @@
+local assetHelper = asset.require('util/asset_helper')
+
+     local spec = {
+         Type = "ScreenSpaceSkyTarget",
+         Identifier = "SkyTarget1",
+         Name = "Target",
+         FaceCamera = false
+     };
+
+assetHelper.registerScreenSpaceRenderables(asset, { spec })

modules/skybrowser/include/screenspaceskybrowser.h

@@ -2,6 +2,7 @@
 #define __OPENSPACE_MODULE_SKYBROWSER___SCREENSPACESKYBROWSER___H__
 
 #include <modules/webbrowser/include/screenspacebrowser.h>
+#include <openspace/properties/stringproperty.h>
 
 namespace openspace {
     class ScreenSpaceSkyTarget;
@@ -12,7 +13,9 @@ namespace openspace {
         ScreenSpaceSkyBrowser(const ghoul::Dictionary& dictionary);
         virtual ~ScreenSpaceSkyBrowser() = default;
 
+        bool initializeGL() override;
         bool deinitializeGL() override;
+        bool setConnectedTarget();
 
         // Communication with the webpage and WWT
         void executeJavascript(std::string& script) const;
@@ -35,7 +38,7 @@ namespace openspace {
         glm::vec2 getUpperRightCornerScreenSpace();
         glm::vec2 getLowerLeftCornerScreenSpace();
         glm::vec2 getScreenSpaceBrowserDimension();
-       
+
         // Mouse interaction
         bool coordIsInsideCornersScreenSpace(glm::vec2 coord);
         glm::vec2 coordIsOnResizeArea(glm::vec2 coord);
@@ -49,13 +52,13 @@ namespace openspace {
         // Flag for dimensions
         bool _browserDimIsDirty;
         properties::FloatProperty _fieldOfView;
-        ScreenSpaceSkyTarget* _skyTarget;
+        properties::StringProperty _skyTargetID;
     private:
         glm::vec2 _startSize;
         float _startScale;
         properties::Vec2Property _browserDimensions;
         bool _camIsSyncedWWT;
-        
+        ScreenSpaceSkyTarget* _skyTarget;
         std::thread _threadWWTMessages;
        
     };

modules/skybrowser/include/screenspaceskytarget.h

@@ -2,20 +2,20 @@
 #define __OPENSPACE_MODULE_SKYBROWSER___SCREENSPACESKYTARGET___H__
 
 #include <openspace/rendering/screenspacerenderable.h>
-
 #include <openspace/documentation/documentation.h>
 #include <openspace/properties/scalar/floatproperty.h>
+#include <openspace/properties/stringproperty.h>
 #include <openspace/properties/vector/vec2property.h>
 #include <openspace/properties/numericalproperty.h>
-
 #include <ghoul/opengl/ghoul_gl.h>
-
 #include <ghoul/opengl/texture.h>
 
 namespace openspace::documentation { struct Documentation; }
 
 namespace openspace {
 
+    class ScreenSpaceSkyBrowser;
+
     class ScreenSpaceSkyTarget : public ScreenSpaceRenderable {
     
     public:
@@ -31,12 +31,15 @@ namespace openspace {
 
         void createShaders();
 
-        void setScreenSpaceTargetDimension(glm::vec2 currentBrowserDimension);
+        void setBrowser(ScreenSpaceSkyBrowser* browser);
+
+        void setDimensions(glm::vec2 currentBrowserDimensions);
         void updateFOV(float fov);
 
         glm::vec2 getScreenSpacePosition();
         glm::vec2 getAnglePosition();
         void setScale(float scale);
+        void setConnectedBrowser();
        
         void translate(glm::vec2 translation, glm::vec2 position);
        
@@ -48,15 +51,16 @@ namespace openspace {
         glm::mat4 scaleMatrix() override;
         
         void bindTexture() override;
+        properties::StringProperty _skyBrowserID;
     private:
     
         properties::Vec2Property _targetDimensions;
         std::unique_ptr<ghoul::opengl::Texture> _texture;
-        //glm::vec2 _browserDimension = glm::vec2(0);
         UniformCache(modelTransform, viewProj, texture, fieldOfView, borderWidth, targetRatio) _uniformCache;
         GLuint _vertexArray = 0;
         GLuint _vertexBuffer = 0;
         float _fieldOfView = 100.f;
+        ScreenSpaceSkyBrowser* _skyBrowser;
     };
 }
 

modules/skybrowser/skybrowsermodule.cpp

@@ -125,16 +125,8 @@ SkyBrowserModule::SkyBrowserModule()
 
     _showBrowserAndTarget.onChange([&]() {
         if (_showBrowserAndTarget) {
-            std::string skyBrowserID;
-            // Tried thread so that the browser would be instantiated... didn't work
-            std::thread createBrowser = std::thread([&] {
-                skyBrowserID = this->createBrowser();
-                });
-            createBrowser.join();
-            // Sky browser is still nullptr
-            _skyBrowser = dynamic_cast<ScreenSpaceSkyBrowser*>(global::renderEngine->screenSpaceRenderable(skyBrowserID));
-            std::string skyTargetID = createTarget(_skyBrowser->getScreenSpaceDimensions());
-            _skyTarget = dynamic_cast<ScreenSpaceSkyTarget*>(global::renderEngine->screenSpaceRenderable(skyTargetID));
+            _skyBrowser->setConnectedTarget();
+            _skyTarget->setConnectedBrowser();
         }
     });
 
@@ -174,7 +166,7 @@ SkyBrowserModule::SkyBrowserModule()
                 // Make sure the browser doesn't move in directions it's not supposed to 
                 _skyBrowser->translate(mouseDragVector * abs(resizeVector) / 2.f, startDragObjectPosBrowser);
 
-                _skyTarget->setScreenSpaceTargetDimension(_skyBrowser->getScreenSpaceBrowserDimension());
+               // _skyTarget->setDimensions(_skyBrowser->getScreenSpaceBrowserDimension());
 
             }
         }
@@ -240,7 +232,6 @@ SkyBrowserModule::SkyBrowserModule()
                 }
                 if (currentlyResizingBrowser) {
                     currentlyResizingBrowser = false;
-                    _skyBrowser->_browserDimIsDirty = false;
                     _skyBrowser->updateBrowserSize();
                     return true;
                 }
@@ -283,67 +274,13 @@ glm::vec2 SkyBrowserModule::getMousePositionInScreenSpaceCoords(glm::vec2& mouse
     return screenSpacePos;
 }
 
-void SkyBrowserModule::initializeBrowser(ScreenSpaceSkyBrowser* skyBrowser, ScreenSpaceSkyTarget* skyTarget) {
-
-    _skyBrowser = skyBrowser;
-    _skyTarget = skyTarget;
-    _skyBrowser->_skyTarget = _skyTarget;
-}
-
-ScreenSpaceSkyBrowser* SkyBrowserModule::skyBrowser() {
-    return _skyBrowser;
-}
-
-std::string SkyBrowserModule::createTarget(glm::ivec2 dimension) {
-
-    std::string browserDim = fmt::format("{{{},{}}}", dimension.x, dimension.y);
-
-    LINFO(browserDim);
-    using namespace std::string_literals;
-
-    std::string ID = "'ScreenSpaceTarget'";
-
-    std::string node = "{"
-        "Type = 'ScreenSpaceSkyTarget',"
-        "Identifier = " + ID + ","
-        "Name = 'Screen Space Target',"
-        "FaceCamera = false,"
-        "TargetDimensions = " + browserDim + ""
-        "}";
-
-    openspace::global::scriptEngine->queueScript(
-        "openspace.addScreenSpaceRenderable(" + node + ")",
-        scripting::ScriptEngine::RemoteScripting::Yes
-    );
-    return ID;
+void SkyBrowserModule::addSkyBrowser(ScreenSpaceSkyBrowser* browser) {
+    _skyBrowser = browser;
 }
 
 
-std::string SkyBrowserModule::createBrowser() {
-
-    using namespace std::string_literals;
-    std::string node = "{"
-        "Type = 'ScreenSpaceSkyBrowser',"
-        "Identifier = 'ScreenSpaceBowser',"
-        "Name = 'Screen Space Bowser',"
-        "Url = 'http://localhost:8000/',"
-        "FaceCamera = false"
-        "}";
-    /*
-    ghoul::Dictionary skyBrowser;
-    std::string ID = "ScreenSpaceSkyBrowser1";
-    skyBrowser.setValue("Type", "ScreenSpaceSkyBrowser"s);
-    skyBrowser.setValue("Identifier", "ScreenSpaceSkyBrowser1"s);
-    skyBrowser.setValue("Name", "Sky Browser"s);
-    skyBrowser.setValue("Url", "http://localhost:8000/"s);
-    skyBrowser.setValue("FaceCamera", "False"s);
-    */
-   
-    openspace::global::scriptEngine->queueScript(
-        "openspace.addScreenSpaceRenderable(" + node + ")",
-        scripting::ScriptEngine::RemoteScripting::Yes
-    );
-    return "ScreenSpaceBowser";
+void SkyBrowserModule::addSkyTarget(ScreenSpaceSkyTarget* target) {
+    _skyTarget = target;
 }
 
 

modules/skybrowser/skybrowsermodule.h

@@ -45,12 +45,10 @@ public:
 
     SkyBrowserModule();
     virtual ~SkyBrowserModule() = default;
-    std::string createBrowser();
-    std::string createTarget(glm::ivec2 dimension);
     glm::vec2 getMousePositionInScreenSpaceCoords(glm::vec2& mousePos);
 
-    void initializeBrowser(ScreenSpaceSkyBrowser* skyBrowser, ScreenSpaceSkyTarget* skyTarget);
-    ScreenSpaceSkyBrowser* skyBrowser();
+    void addSkyBrowser(ScreenSpaceSkyBrowser* browser);
+    void addSkyTarget(ScreenSpaceSkyTarget* target);
     scripting::LuaLibrary luaLibrary() const override;
     //std::vector<documentation::Documentation> documentations() const override;
 

modules/skybrowser/skybrowsermodule_lua.inl

@@ -33,45 +33,24 @@ namespace openspace::skybrowser::luascriptfunctions {
 
     int loadImgCollection(lua_State* L) {
         ghoul::lua::checkArgumentsAndThrow(L, 1, "lua::loadCollection");
-        // https://docs.worldwidetelescope.org/data-guide/1/data-file-formats/collections/sample-blank-collection.wtml
-        std::string url = ghoul::lua::value<std::string>(L, 1);
-        SkyBrowserModule* module = global::moduleEngine->module<SkyBrowserModule>();
-        module->skyBrowser()->sendMessageToWWT(module->skyBrowser()->createMessageForLoadingWWTImgColl(url));
+
         return 1;
     }
     
     int followCamera(lua_State* L) {
         ghoul::lua::checkArgumentsAndThrow(L, 0, "lua::followCamera");
-
-        SkyBrowserModule* module = global::moduleEngine->module<SkyBrowserModule>();
-        ScreenSpaceSkyTarget* target = dynamic_cast<ScreenSpaceSkyTarget*>(global::renderEngine->screenSpaceRenderable("ScreenSpaceTarget"));
-        ScreenSpaceSkyBrowser* browser = dynamic_cast<ScreenSpaceSkyBrowser*>(global::renderEngine->screenSpaceRenderable("ScreenSpaceBowser"));
-
-        module->initializeBrowser(browser, target);
-        module->skyBrowser()->translate(glm::vec3(-0.8, -0.4, 0.0));
-
-        browser->WWTfollowCamera();
         
         return 1;
     }
 
     int moveBrowser(lua_State* L) {
         ghoul::lua::checkArgumentsAndThrow(L, 0, "lua::moveBrowser");
-
-        SkyBrowserModule* module = global::moduleEngine->module<SkyBrowserModule>();    
-        ScreenSpaceSkyBrowser* browser = dynamic_cast<ScreenSpaceSkyBrowser*>(global::renderEngine->screenSpaceRenderable("ScreenSpaceBowser"));
-
-        // target test
-        module->createTarget(browser->getScreenSpaceBrowserDimension());
-
         return 1;
     }
 
     int createBrowser(lua_State* L) {
         ghoul::lua::checkArgumentsAndThrow(L, 0, "lua::createBrowser");
 
-        SkyBrowserModule* module = global::moduleEngine->module<SkyBrowserModule>();
-        module->createBrowser();
 
         return 1;
     }

modules/skybrowser/src/screenspaceskybrowser.cpp

@@ -1,5 +1,6 @@
 #include <modules/skybrowser/include/screenspaceskybrowser.h>
 #include <modules/skybrowser/include/screenspaceskytarget.h>
+#include <modules/skybrowser/skybrowsermodule.h>
 #include <modules/webbrowser/include/webkeyboardhandler.h>
 #include <modules/webbrowser/include/browserinstance.h>
 #include <modules/webbrowser/include/screenspacebrowser.h>
@@ -8,6 +9,7 @@
 #include <openspace/engine/windowdelegate.h>
 #include <openspace/interaction/navigationhandler.h>
 #include <openspace/rendering/renderengine.h>
+#include <openspace/engine/moduleengine.h>
 #include <openspace/util/camera.h>
 #include <openspace/scene/scene.h>
 #include <ghoul/misc/dictionaryjsonformatter.h> // formatJson
@@ -35,6 +37,12 @@ namespace {
         "Zoom Info",
         "tjobidabidobidabidopp plupp"
     };
+    constexpr const openspace::properties::Property::PropertyInfo TargetIDInfo =
+    {
+        "TargetID",
+        "Target Info",
+        "tjobidabidobidabidopp plupp"
+    };
 
 
     struct [[codegen::Dictionary(ScreenSpaceSkyBrowser)]] Parameters {
@@ -44,6 +52,9 @@ namespace {
 
         // [[codegen::verbatim(ZoomInfo.description)]]
         std::optional<float> zoom;
+
+        // [[codegen::verbatim(TargetIDInfo.description)]]
+        std::optional<std::string> targetID;
     };
 
 #include "screenspaceskybrowser_codegen.cpp"
@@ -54,17 +65,33 @@ namespace openspace {
         : ScreenSpaceBrowser(dictionary)
         , _browserDimensions(BrowserDimensionInfo, _dimensions, glm::ivec2(0.f), glm::ivec2(300.f))
         , _fieldOfView(ZoomInfo, 50.f, 0.1f, 70.f)
+        , _skyTargetID(TargetIDInfo)
         , _camIsSyncedWWT(true)
+        , _skyTarget(nullptr)
     {
         // Handle target dimension property
         const Parameters p = codegen::bake<Parameters>(dictionary);
         _browserDimensions = p.browserDimensions.value_or(_browserDimensions);
-        _browserDimensions.onChange([&]() { _browserDimIsDirty = true; });
+        _browserDimensions.onChange([&]() { 
+            if (!_skyTarget) {
+                setConnectedTarget();
+            }
+            else {
+                _skyTarget->setDimensions(getScreenSpaceBrowserDimension());
+            }
+            });
         addProperty(_browserDimensions);
 
         _fieldOfView = p.zoom.value_or(_fieldOfView);
         addProperty(_fieldOfView);
 
+        _skyTargetID = p.targetID.value_or(_skyTargetID);
+        addProperty(_skyTargetID);
+
+        _skyTargetID.onChange([&]() {
+            setConnectedTarget();
+            });
+
         _fieldOfView.onChange([&]() {
             if (_skyTarget) {
                 _skyTarget->updateFOV(_fieldOfView);
@@ -72,7 +99,7 @@ namespace openspace {
                 _skyTarget->setScale(std::max(static_cast<float>(_fieldOfView / global::windowDelegate->getHorizFieldOfView()), scaleWhenFovIs10));
             }
             });
-
+        
         std::string identifier;
         if (dictionary.hasValue<std::string>(KeyIdentifier)) {
             identifier = dictionary.value<std::string>(KeyIdentifier);
@@ -87,6 +114,18 @@ namespace openspace {
         _cartesianPosition.setValue(glm::vec3(_cartesianPosition.value().x, _cartesianPosition.value().y, -2.1f));
     }
 
+    bool ScreenSpaceSkyBrowser::initializeGL() {
+        global::moduleEngine->module<SkyBrowserModule>()->addSkyBrowser(this);
+        setConnectedTarget();
+        if (_skyTarget) {    
+            _skyTarget->setDimensions(getScreenSpaceBrowserDimension());
+        }
+
+        WWTfollowCamera();
+
+        return ScreenSpaceBrowser::initializeGL();
+    }
+
     bool ScreenSpaceSkyBrowser::deinitializeGL() {
         // Set flag to false so the thread can exit
         _camIsSyncedWWT = false;
@@ -97,6 +136,11 @@ namespace openspace {
         return ScreenSpaceBrowser::deinitializeGL();
     }   
 
+    bool ScreenSpaceSkyBrowser::setConnectedTarget() {
+        _skyTarget = dynamic_cast<ScreenSpaceSkyTarget*>(global::renderEngine->screenSpaceRenderable(_skyTargetID.value()));
+        return _skyTarget != nullptr;
+    }
+
     float ScreenSpaceSkyBrowser::fieldOfView() const {
         return _fieldOfView;
     }
@@ -133,6 +177,7 @@ namespace openspace {
     }
 
     ghoul::Dictionary ScreenSpaceSkyBrowser::createMessageForLoadingWWTImgColl(const std::string& url) const {
+        // https://docs.worldwidetelescope.org/data-guide/1/data-file-formats/collections/sample-blank-collection.wtml
         using namespace std::string_literals;
         ghoul::Dictionary msg;
         msg.setValue("event", "center_on_coordinates"s);
@@ -184,9 +229,8 @@ namespace openspace {
                 // Sleep so we don't bombard WWT with too many messages
                 std::this_thread::sleep_for(std::chrono::milliseconds(50));
                 sendMessageToWWT(message);
-
             }
-            });
+        });
 
     }
 

modules/skybrowser/src/screenspaceskytarget.cpp

@@ -1,5 +1,6 @@
 #include <modules/skybrowser/include/screenspaceskytarget.h>
-
+#include <modules/skybrowser/include/screenspaceskybrowser.h>
+#include <modules/skybrowser/skybrowsermodule.h>
 #include <openspace/engine/globals.h>
 #include <openspace/scripting/scriptengine.h>
 #include <ghoul/misc/dictionaryluaformatter.h>
@@ -14,6 +15,7 @@
 
 #include <openspace/scripting/scriptengine.h>
 #include <openspace/engine/windowdelegate.h>
+#include <openspace/engine/moduleengine.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/texture.h>
@@ -41,10 +43,20 @@ namespace {
         "ModelTransform", "ViewProjectionMatrix", "texture1", "fieldOfView", "borderWidth", "targetRatio"
     };
 
+    constexpr const openspace::properties::Property::PropertyInfo BrowserIDInfo =
+    {
+        "BrowserID",
+        "Browser Info",
+        "tjobidabidobidabidopp plupp"
+    };
+
     struct [[codegen::Dictionary(ScreenSpaceSkyTarget)]] Parameters {
 
         // [[codegen::verbatim(TargetDimensionInfo.description)]]
         std::optional<glm::vec2> targetDimensions;
+
+        // [[codegen::verbatim(BrowserIDInfo.description)]]
+        std::optional<std::string> browserID;
     };
 
 #include "screenspaceskytarget_codegen.cpp"
@@ -55,12 +67,19 @@ namespace openspace {
     ScreenSpaceSkyTarget::ScreenSpaceSkyTarget(const ghoul::Dictionary& dictionary)
         : ScreenSpaceRenderable(dictionary)
         , _targetDimensions(TargetDimensionInfo, glm::ivec2(1000.f), glm::ivec2(0.f), glm::ivec2(6000.f))
+        , _skyBrowserID(BrowserIDInfo)
     {
         // Handle target dimension property
         const Parameters p = codegen::bake<Parameters>(dictionary);
         _targetDimensions = p.targetDimensions.value_or(_targetDimensions);
         
         addProperty(_targetDimensions);
+        _skyBrowserID = p.browserID.value_or(_skyBrowserID);
+        addProperty(_skyBrowserID);
+
+        _skyBrowserID.onChange([&]() {
+            setConnectedBrowser();
+            });
 
 
         std::string identifier;
@@ -73,25 +92,6 @@ namespace openspace {
         identifier = makeUniqueIdentifier(identifier);
         setIdentifier(identifier);
 
-       
-
-        /*
-        std::unique_ptr<ghoul::opengl::Texture> texture =
-            ghoul::io::TextureReader::ref().loadTexture(absPath("D:/Ylvas/OpenSpace/modules/skybrowser/target.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();
-        }
-        */
         _cartesianPosition.setValue(glm::vec3(_cartesianPosition.value().x, _cartesianPosition.value().y, -2.1f));
 
     }
@@ -106,11 +106,18 @@ namespace openspace {
         _scale = scale;
     }
 
+    void ScreenSpaceSkyTarget::setConnectedBrowser() {
+        _skyBrowser = dynamic_cast<ScreenSpaceSkyBrowser*>(global::renderEngine->screenSpaceRenderable(_skyBrowserID.value()));
+    }
+
     bool ScreenSpaceSkyTarget::isReady() const {
         return _shader != nullptr;
     }
 
     bool ScreenSpaceSkyTarget::initializeGL() {
+        global::moduleEngine->module<SkyBrowserModule>()->addSkyTarget(this);
+
+        setConnectedBrowser();
 
         glGenVertexArrays(1, &_vertexArray);
         glGenBuffers(1, &_vertexBuffer);
@@ -164,6 +171,10 @@ namespace openspace {
 
     }
 
+    void ScreenSpaceSkyTarget::setBrowser(ScreenSpaceSkyBrowser* browser) {
+        _skyBrowser = browser;
+    }
+
     void ScreenSpaceSkyTarget::render() {
 
         glDisable(GL_CULL_FACE);
@@ -236,8 +247,8 @@ namespace openspace {
         return  lessThanUpperRight && moreThanLowerLeft;
     }
 
-    void ScreenSpaceSkyTarget::setScreenSpaceTargetDimension(glm::vec2 currentBrowserDimension) {
-        _targetDimensions = currentBrowserDimension;    
+    void ScreenSpaceSkyTarget::setDimensions(glm::vec2 currentBrowserDimensions) {
+        _targetDimensions = currentBrowserDimensions;    
     }
 
     void ScreenSpaceSkyTarget::updateFOV(float fov) {