ScreenSpaceRenderables can be creates through scripts, ScreenSpaceRenderable is now a factory

include/openspace/rendering/screenspacerenderable.h

@@ -53,6 +53,7 @@ namespace openspace {
  */
 class ScreenSpaceRenderable : public properties::PropertyOwner {
 public:
+    static ScreenSpaceRenderable* createFromDictionary(const ghoul::Dictionary& dictionary);
     ScreenSpaceRenderable();
     ~ScreenSpaceRenderable();
 

modules/base/basemodule.cpp

@@ -25,6 +25,7 @@
 #include <modules/base/basemodule.h>
 
 #include <openspace/rendering/renderable.h>
+#include <openspace/rendering/screenspacerenderable.h>
 #include <openspace/util/factorymanager.h>
 
 #include <ghoul/misc/assert.h>
@@ -42,6 +43,8 @@
 #include <modules/base/rendering/simplespheregeometry.h>
 #include <modules/base/rendering/modelgeometry.h>
 #include <modules/base/rendering/multimodelgeometry.h>
+#include <modules/base/rendering/screenspaceimage.h>
+#include <modules/base/rendering/screenspaceframebuffer.h>
 
 #include <modules/base/ephemeris/staticephemeris.h>
 #include <modules/base/ephemeris/dynamicephemeris.h>
@@ -59,6 +62,12 @@ void BaseModule::internalInitialize() {
     FactoryManager::ref().addFactory(std::make_unique<ghoul::TemplateFactory<planetgeometry::PlanetGeometry>>());
     FactoryManager::ref().addFactory(std::make_unique<ghoul::TemplateFactory<modelgeometry::ModelGeometry>>());
 
+    auto fScreenSpaceRenderable = FactoryManager::ref().factory<ScreenSpaceRenderable>();
+    ghoul_assert(fScreenSpaceRenderable, "ScreenSpaceRenderable factory was not created");
+
+    fScreenSpaceRenderable->registerClass<ScreenSpaceImage>("ScreenSpaceImage");
+    fScreenSpaceRenderable->registerClass<ScreenSpaceFramebuffer>("ScreenSpaceFramebuffer");
+
     auto fRenderable = FactoryManager::ref().factory<Renderable>();
     ghoul_assert(fRenderable, "Renderable factory was not created");
 

modules/base/rendering/screenspaceframebuffer.cpp

@@ -32,7 +32,7 @@
 #include <openspace/rendering/framebufferrenderer.h>
 
 namespace openspace {
-ScreenSpaceFramebuffer::ScreenSpaceFramebuffer() 
+ScreenSpaceFramebuffer::ScreenSpaceFramebuffer(const ghoul::Dictionary& dictionary) 
     :ScreenSpaceRenderable()
     ,_size("size", "Size", glm::vec4(0), glm::vec4(0), glm::vec4(2000))
     ,_framebuffer(nullptr)

modules/base/rendering/screenspaceframebuffer.h

@@ -38,7 +38,7 @@ namespace openspace {
  */
 class ScreenSpaceFramebuffer : public ScreenSpaceRenderable {
 public:
-    ScreenSpaceFramebuffer();
+    ScreenSpaceFramebuffer(const ghoul::Dictionary& dictionary = ghoul::Dictionary());
     ~ScreenSpaceFramebuffer();
 
     bool initialize() override;

modules/base/rendering/screenspaceimage.cpp

@@ -33,7 +33,6 @@ namespace openspace {
 ScreenSpaceImage::ScreenSpaceImage(std::string texturePath)
     :ScreenSpaceRenderable()
     ,_texturePath("texturePath", "Texture path", texturePath)
-
 {
     _id = id();
     setName("ScreenSpaceImage" + std::to_string(_id));
@@ -45,6 +44,24 @@ ScreenSpaceImage::ScreenSpaceImage(std::string texturePath)
     _texturePath.onChange([this](){ loadTexture(); });
 }
 
+ScreenSpaceImage::ScreenSpaceImage(const ghoul::Dictionary& dictionary)
+    :ScreenSpaceRenderable()
+    ,_texturePath("texturePath", "Texture path", "")
+{
+    _id = id();
+    setName("ScreenSpaceImage" + std::to_string(_id));
+
+    std::string texturePath;
+    dictionary.getValue("TexturePath", texturePath);
+    _texturePath.set(texturePath);
+
+    registerProperties();
+
+    addProperty(_texturePath);
+    OsEng.gui()._screenSpaceProperty.registerProperty(&_texturePath);    
+    _texturePath.onChange([this](){ loadTexture(); });
+}
+
 ScreenSpaceImage::~ScreenSpaceImage(){}
 
 bool ScreenSpaceImage::initialize(){

modules/base/rendering/screenspaceimage.h

@@ -39,6 +39,7 @@ class ScreenSpaceImage : public ScreenSpaceRenderable {
 
 public:
     ScreenSpaceImage(std::string texturePath);
+    ScreenSpaceImage(const ghoul::Dictionary& dictionary);
     ~ScreenSpaceImage();
 
     bool initialize() override;

modules/iswa/iswamodule.cpp

@@ -25,6 +25,7 @@
 #include <modules/iswa/iswamodule.h>
 
 #include <openspace/rendering/renderable.h>
+#include <openspace/rendering/screenspacerenderable.h>
 #include <openspace/util/factorymanager.h>
 
 #include <ghoul/misc/assert.h>
@@ -33,6 +34,7 @@
 #include <modules/iswa/rendering/textureplane.h>
 #include <modules/iswa/rendering/dataplane.h>
 #include <modules/iswa/rendering/kameleonplane.h>
+#include <modules/iswa/rendering/screenspacecygnet.h>
 
 namespace openspace {
 
@@ -41,6 +43,7 @@ namespace openspace {
     {}
 
     void ISWAModule::internalInitialize(){
+        FactoryManager::ref().addFactory(std::make_unique<ghoul::TemplateFactory<ScreenSpaceRenderable>>());
         auto fRenderable = FactoryManager::ref().factory<Renderable>();
         ghoul_assert(fRenderable, "No renderable factory existed");
 
@@ -48,5 +51,10 @@ namespace openspace {
         fRenderable->registerClass<TexturePlane>("TexturePlane");
         fRenderable->registerClass<DataPlane>("DataPlane");
         fRenderable->registerClass<KameleonPlane>("KameleonPlane");
+
+        auto fScreenSpaceRenderable = FactoryManager::ref().factory<ScreenSpaceRenderable>();
+        ghoul_assert(fScreenSpaceRenderable, "No fScreenSpaceRenderable factory existed");
+
+        fScreenSpaceRenderable->registerClass<ScreenSpaceCygnet>("ScreenSpaceCygnet");
     }
 }

modules/iswa/rendering/screenspacecygnet.cpp

@@ -45,6 +45,21 @@ ScreenSpaceCygnet::ScreenSpaceCygnet(int cygnetId)
     registerProperties();
 }
 
+ScreenSpaceCygnet::ScreenSpaceCygnet(const ghoul::Dictionary& dictionary)
+    : ScreenSpaceRenderable()
+    , _updateInterval("updateInterval", "Update Interval", 1.0, 0.0 , 10.0)
+{
+    // hacky, have to first get as float and the cast to int.
+    float cygnetid;
+    dictionary.getValue("CygnetId", cygnetid);
+    _cygnetId = (int)cygnetid;
+    
+    setName("iSWACygnet" + std::to_string(_cygnetId));
+    addProperty(_updateInterval);
+
+    registerProperties();
+}
+
 ScreenSpaceCygnet::~ScreenSpaceCygnet(){}
 
 bool ScreenSpaceCygnet::initialize(){

modules/iswa/rendering/screenspacecygnet.h

@@ -35,6 +35,7 @@ namespace openspace{
 class ScreenSpaceCygnet : public ScreenSpaceRenderable {
 public:
     ScreenSpaceCygnet(int cygnetId);
+    ScreenSpaceCygnet(const ghoul::Dictionary& dictionary);
     ~ScreenSpaceCygnet();
 
     void render() override;
@@ -47,7 +48,7 @@ private:
     void updateTexture();
     void loadTexture();
 
-    const int _cygnetId;
+    int _cygnetId;
 
     properties::FloatProperty _updateInterval;
     std::chrono::milliseconds _realTime;

modules/iswa/util/iswamanager.cpp

@@ -305,7 +305,9 @@ namespace openspace{
     }
 
     void ISWAManager::createScreenSpace(int id){
-        OsEng.renderEngine().registerScreenSpaceRenderable(std::make_shared<ScreenSpaceCygnet>(id));
+        std::string luaTable = "{ Type='ScreenSpaceCygnet', CygnetId = "+std::to_string(id)+"}";
+        std::string script = "openspace.registerScreenSpaceRenderable(" + luaTable + ");";
+        OsEng.scriptEngine().queueScript(script);
     }
 
     void ISWAManager::createKameleonPlane(std::string kwPath){

src/rendering/renderengine.cpp

@@ -380,7 +380,7 @@ void RenderEngine::postSynchronizationPreDraw() {
         _deletedScreenSpaceRenderables.clear(); 
     
     for (auto screenspacerenderable : _screenSpaceRenderables) {
-        screenspacerenderable->update();
+            screenspacerenderable->update();
     }
     //Allow focus node to update camera (enables camera-following)
     //FIX LATER: THIS CAUSES MASTER NODE TO BE ONE FRAME AHEAD OF SLAVES
@@ -646,6 +646,12 @@ scripting::ScriptEngine::LuaLibrary RenderEngine::luaLibrary() {
                 "",
                 true
             },
+            {
+                "registerScreenSpaceRenderable",
+                &luascriptfunctions::registerScreenSpaceRenderable,
+                "table",
+                "Will create a ScreenSpaceRenderable from a lua Table and register it in the RenderEngine"
+            },
         },
     };
 }

src/rendering/renderengine_lua.inl

@@ -133,6 +133,29 @@ int fadeOut(lua_State* L) {
 	return 0;
 }
 
+int registerScreenSpaceRenderable(lua_State* L) {
+    static const std::string _loggerCat = "registerScreenSpaceRenderable";
+    using ghoul::lua::errorLocation;
+
+    int nArguments = lua_gettop(L);
+	if (nArguments != 1)
+		return luaL_error(L, "Expected %i arguments, got %i", 1, nArguments);
+
+    ghoul::Dictionary d;
+    try {
+        ghoul::lua::luaDictionaryFromState(L, d);
+    }
+    catch (const ghoul::lua::LuaFormatException& e) {
+        LERROR(e.what());
+        return 0;
+    }
+	
+	std::shared_ptr<ScreenSpaceRenderable> s( ScreenSpaceRenderable::createFromDictionary(d) );
+    OsEng.renderEngine().registerScreenSpaceRenderable(s);
+      
+    return 1;
+}
+
 } // namespace luascriptfunctions
 
 }// namespace openspace

src/rendering/screenspacerenderable.cpp

@@ -23,8 +23,37 @@
  ****************************************************************************************/
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/screenspacerenderable.h>
+#include <openspace/util/factorymanager.h>
+
+namespace {
+    const std::string _loggerCat = "ScreenSpaceRenderable";
+    const std::string KeyType = "Type";
+}
 
 namespace openspace {
+
+ScreenSpaceRenderable* ScreenSpaceRenderable::createFromDictionary(const ghoul::Dictionary& dictionary) {
+
+    std::string renderableType;
+    bool success = dictionary.getValue(KeyType, renderableType);
+
+    if (!success) {
+        LERROR("ScreenSpaceRenderable did not have key '" << KeyType << "'");
+        return nullptr;
+    }
+
+    ghoul::TemplateFactory<ScreenSpaceRenderable>* factory
+          = FactoryManager::ref().factory<ScreenSpaceRenderable>();
+    ScreenSpaceRenderable* result = factory->create(renderableType, dictionary);
+    if (result == nullptr) {
+        LERROR("Failed to create a ScreenSpaceRenderable object of type '" << renderableType << "'");
+        return nullptr;
+    }
+
+    return result;
+}
+
+
 ScreenSpaceRenderable::ScreenSpaceRenderable()
     :_enabled("enabled", "Is Enabled", true)
     ,_useFlatScreen("flatScreen", "Flat Screen", true)