ScreenSpaceRenderabled enabled propery in GUI

include/openspace/rendering/renderengine.h

@@ -100,6 +100,7 @@ public:
 
     void registerScreenSpaceRenderable(std::shared_ptr<ScreenSpaceRenderable> s);
     void unregisterScreenSpaceRenderable(std::shared_ptr<ScreenSpaceRenderable> s);
+    std::shared_ptr<ScreenSpaceRenderable> screenSpaceRenderable(std::string name);
 
     std::unique_ptr<ghoul::opengl::ProgramObject> buildRenderProgram(
         std::string name,

include/openspace/rendering/screenspacerenderable.h

@@ -41,13 +41,16 @@ public:
 	virtual bool deinitialize() = 0;
 	virtual void update() = 0;
 	virtual bool isReady() const = 0;
+	bool isEnabled() const;
 
 protected:
 	void createPlane();
 
 	properties::BoolProperty _enabled;
+	properties::BoolProperty _flatScreen;
 	properties::Vec3Property _position;
 	properties::Vec2Property _size;
+	properties::FloatProperty _scale;
 
 	GLuint _quad;
 	GLuint _vertexPositionBuffer;

modules/base/rendering/screenspaceimage.cpp

@@ -27,21 +27,27 @@
 #include <openspace/rendering/renderengine.h>
 #include <openspace/engine/openspaceengine.h>
 #include <ghoul/opengl/textureunit.h>
+#include <modules/onscreengui/include/gui.h>
 
 namespace openspace {
 	ScreenSpaceImage::ScreenSpaceImage()
 		:ScreenSpaceRenderable()
-	{}
+	{
+		setName("ScreenSpaceImage");
+		_enabled.onChange([this](){});
+	}
 
 	ScreenSpaceImage::~ScreenSpaceImage(){}
 
 
 void ScreenSpaceImage::render(){
-	glm::mat4 transform = glm::mat4(1.0);
-	// using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
-    _shader->activate();
-    // _shader->setIgnoreUniformLocationError(IgnoreError::Yes);
+	glm::mat4 transform = glm::translate(glm::mat4(1.f), _position.value());
+	transform = glm::scale(transform, glm::vec3(_scale.value()));
 
+    // transform.translate(position.value());
+    _shader->activate();
+
+    _shader->setUniform("ModelTransform",transform);
 
 	ghoul::opengl::TextureUnit unit;
 	unit.activate();
@@ -55,6 +61,9 @@ void ScreenSpaceImage::render(){
 }
 
 bool ScreenSpaceImage::initialize(){
+	std::cout << "initializeing" << std::endl;
+	OsEng.gui()._property.registerProperty(&_enabled);
+
 	glGenVertexArrays(1, &_quad); // generate array
 	glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
 	createPlane();

modules/base/shaders/screnspace_vs.glsl

@@ -38,5 +38,5 @@ void main(){
 	vs_st = in_st;
 	vs_position = in_position; 
 
-	gl_Position = vs_position;
+	gl_Position = ModelTransform*vs_position;
 }

openspace.cfg

@@ -7,7 +7,7 @@ return {
 
     -- Sets the scene that is to be loaded by OpenSpace. A scene file is a description
     -- of all entities that will be visible during an instance of OpenSpace
-    Scene = "${SCENE}/default_nh.scene",
+    Scene = "${SCENE}/default.scene",
 
     Paths = {
         SGCT = "${BASE_PATH}/config/sgct",

src/query/query.cpp

@@ -30,6 +30,7 @@
 #include <openspace/rendering/renderable.h>
 #include <openspace/scene/scene.h>
 #include <openspace/scene/scenegraphnode.h>
+#include <openspace/rendering/screenspacerenderable.h>
 
 namespace openspace {
 
@@ -59,24 +60,29 @@ properties::Property* property(const std::string& uri) {
     else {
         // The URI consists of the following form at this stage:
         // <node name>.{<property owner>.}^(0..n)<property id>
-        
-        const size_t nodeNameSeparator = uri.find(properties::PropertyOwner::URISeparator);
-        if (nodeNameSeparator == std::string::npos) {
-            LERROR("Malformed URI '" << uri << "': At least one '" << nodeNameSeparator
+        const size_t nameSeparator = uri.find(properties::PropertyOwner::URISeparator);
+        if (nameSeparator == std::string::npos) {
+            LERROR("Malformed URI '" << uri << "': At least one '" << nameSeparator
                    << "' separator must be present.");
             return nullptr;
         }
-        const std::string nodeName = uri.substr(0, nodeNameSeparator);
-        const std::string remainingUri = uri.substr(nodeNameSeparator + 1);
+        const std::string nameUri = uri.substr(0, nameSeparator);
+        const std::string remainingUri = uri.substr(nameSeparator + 1);
 
-        SceneGraphNode* node = sceneGraphNode(nodeName);
-        if (!node) {
-            LERROR("Node '" << nodeName << "' did not exist");
-            return nullptr;
+        SceneGraphNode* node = sceneGraphNode(nameUri);
+        if (node) {
+            properties::Property* property = node->property(remainingUri);
+            return property;
+        }
+
+        std::shared_ptr<ScreenSpaceRenderable> ssr = OsEng.renderEngine().screenSpaceRenderable(nameUri);
+        if(ssr){
+            properties::Property* property = ssr->property(remainingUri);
+            return property;
         }
         
-        properties::Property* property = node->property(remainingUri);
-        return property;
+        LERROR("Node or ScreenSpaceRenderable'" << nameUri << "' did not exist");
+        return nullptr;
     }
 }
 

src/rendering/renderengine.cpp

@@ -395,7 +395,8 @@ void RenderEngine::render(const glm::mat4 &projectionMatrix, const glm::mat4 &vi
 	}
 
 	for (auto s : _screenSpaceRenderables) {
-		s->render();
+		if(s->isEnabled())
+			s->render();
 	}
 }
 
@@ -1132,6 +1133,15 @@ void RenderEngine::unregisterScreenSpaceRenderable(std::shared_ptr<ScreenSpaceRe
 	}
 }
 
+std::shared_ptr<ScreenSpaceRenderable> RenderEngine::screenSpaceRenderable(std::string name){
+	for(auto s : _screenSpaceRenderables){
+		if(s->name() == name){
+			return s;
+		}
+	}
+	return nullptr;
+}
+
 RenderEngine::RendererImplementation RenderEngine::rendererFromString(const std::string& impl) {
     const std::map<std::string, RenderEngine::RendererImplementation> RenderingMethods = {
         { "ABuffer", RendererImplementation::ABuffer },

src/rendering/screenspacerenderable.cpp

@@ -21,23 +21,32 @@
  * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
+#include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/screenspacerenderable.h>
 
 namespace openspace {
 	ScreenSpaceRenderable::ScreenSpaceRenderable()
 		: _enabled("enabled", "Is Enabled", true)
-		, _position("position", "Position", glm::vec3(0,0,0))
-		, _size("size", "Size" , glm::vec2(0.5,1.0))
+		, _flatScreen("flatScreen", "Flat Screen", true)
+		, _position("position", "Position", glm::vec3(1,0,0))
+		, _size("size", "Size" , glm::vec2(1.0,1.0))
+		, _scale("scale", "Scale" , 0.5)
 		, _quad(0)
 		, _vertexPositionBuffer(0)
 	{
 		addProperty(_enabled);
+		addProperty(_flatScreen);
 		addProperty(_position);
 		addProperty(_size);
+		addProperty(_scale);
 	}
 
 	ScreenSpaceRenderable::~ScreenSpaceRenderable(){}
 
+	bool ScreenSpaceRenderable::isEnabled() const {
+		return _enabled;
+	}
+
 	void ScreenSpaceRenderable::createPlane() {
 	    // ============================
 	    // 		GEOMETRY (quad)