solved merge conflict

include/openspace/rendering/screenspacerenderable.h

@@ -35,8 +35,7 @@ namespace openspace {
 
 class ScreenSpaceRenderable : public properties::PropertyOwner {
 public:
-
-	ScreenSpaceRenderable();
+	ScreenSpaceRenderable(std::string texturePath);
 	~ScreenSpaceRenderable();
 
 	virtual void render(Camera* camera) = 0;

modules/base/rendering/screenspaceimage.cpp

@@ -30,11 +30,11 @@
 #include <modules/onscreengui/include/gui.h>
 
 namespace openspace {
-	ScreenSpaceImage::ScreenSpaceImage()
-		:ScreenSpaceRenderable()
+ScreenSpaceImage::ScreenSpaceImage(std::string texturePath)
+		:ScreenSpaceRenderable(texturePath)
 	{
-		setName("ScreenSpaceImage");
 
+		setName("ScreenSpaceImage" + std::to_string(id()));
 		OsEng.gui()._property.registerProperty(&_enabled);
 		OsEng.gui()._property.registerProperty(&_flatScreen);
 		OsEng.gui()._property.registerProperty(&_position);
@@ -44,16 +44,20 @@ namespace openspace {
 		_texturePath.onChange([this](){ loadTexture(); });
 	}
 
-	ScreenSpaceImage::~ScreenSpaceImage(){}
+ScreenSpaceImage::~ScreenSpaceImage(){}
 
 
 void ScreenSpaceImage::render(Camera* camera){
-	GLint m_viewport[4];
-	glGetIntegerv(GL_VIEWPORT, m_viewport);
+
+	GLfloat m_viewport[4];
+	glGetFloatv(GL_VIEWPORT, m_viewport);
 	float height =  (float(_texture->height())/float(_texture->width()));
 
+	float scalingRatioX = m_viewport[2] / _originalViewportSize[0];
+	float scalingRatioY = m_viewport[3] / _originalViewportSize[1];
+
 	glm::mat4 transform = glm::translate(glm::mat4(1.f), _position.value());
-	transform = glm::scale(transform, glm::vec3(_scale.value(),_scale.value()*height,1));
+	transform = glm::scale(transform, glm::vec3(_scale.value()*scalingRatioY, _scale.value()*height*scalingRatioX, 1));
 
     _shader->activate();
 
@@ -85,7 +89,9 @@ bool ScreenSpaceImage::initialize(){
         if (!_shader)
             return false;
 	}
-
+	GLfloat m_viewport[4];
+	glGetFloatv(GL_VIEWPORT, m_viewport);
+	_originalViewportSize = glm::vec2(m_viewport[2], m_viewport[3]);
 	loadTexture();
 
 	return isReady();
@@ -111,7 +117,6 @@ void ScreenSpaceImage::loadTexture() {
         std::unique_ptr<ghoul::opengl::Texture> texture = ghoul::io::TextureReader::ref().loadTexture(absPath(_texturePath.value()));
 		if (texture) {
 			// LDEBUG("Loaded texture from '" << absPath(_texturePath) << "'");
-			// std::cout<< std::endl << std::endl << "Loaded texture from '" << absPath(_texturePath) << "'" <<std::endl << std::endl;
 			texture->uploadTexture();
 
 			// Textures of planets looks much smoother with AnisotropicMipMap rather than linear
@@ -125,4 +130,9 @@ void ScreenSpaceImage::loadTexture() {
 		}
 	}
 }
+
+int ScreenSpaceImage::id(){
+		static int id = 0;
+		return id++;
+}
 }

modules/base/rendering/screenspaceimage.h

@@ -31,7 +31,7 @@ namespace openspace {
 class ScreenSpaceImage : public ScreenSpaceRenderable {
 
 public:
-	ScreenSpaceImage();
+	ScreenSpaceImage(std::string texturePath);
 	~ScreenSpaceImage();
 
 	void render(Camera* camera) override;
@@ -41,8 +41,11 @@ public:
 	bool isReady() const override;
 private:
 	void loadTexture();
+	static int id();
+	
 	std::unique_ptr<ghoul::opengl::Texture>  _texture; // The image to render
-
+	glm::vec2 _originalViewportSize;
 };
+// int ScreenSpaceImage::id = 0;
 } //namespace openspace
 #endif //__SCREENSPACEIMAGE_H__

modules/base/shaders/screnspace_vs.glsl

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

modules/onscreengui/src/gui.cpp

@@ -34,6 +34,9 @@
 #include <ghoul/filesystem/cachemanager.h>
 #include <openspace/properties/property.h>
 #include <openspace/rendering/renderengine.h>
+#include <openspace/rendering/screenspacerenderable.h>
+#include <modules/base/rendering/screenspaceimage.h>
+
 
 #include <ghoul/opengl/ghoul_gl.h>
 #include <ghoul/opengl/programobject.h>
@@ -129,6 +132,16 @@ namespace {
 }
 
 namespace openspace {
+	void addScreenSpaceRenderable(std::string texturePath){
+		std::string filepath ="${OPENSPACE_DATA}/"+texturePath;
+		if( ! FileSys.fileExists(filepath)) {
+			LWARNING("Could not find image '" << filepath << "'");
+			return;
+		}
+		OsEng.renderEngine().registerScreenSpaceRenderable(std::make_shared<ScreenSpaceImage>(filepath));
+	}
+
+
 namespace gui {
 
 GUI::GUI() 
@@ -392,6 +405,14 @@ void GUI::renderMainWindow() {
 
 	ImGui::Checkbox("Help", &_help._isEnabled);
 
+	static const int bufferSize = 256;
+    static char buffer[bufferSize];
+	ImGui::InputText("", buffer, bufferSize);
+
+	if(ImGui::SmallButton("Add Image")){
+		addScreenSpaceRenderable(std::string(buffer));
+	}
+
 	ImGui::End();
 }
 

src/rendering/renderengine.cpp

@@ -206,8 +206,7 @@ bool RenderEngine::initialize() {
   
     ghoul::io::TextureReader::ref().addReader(std::make_shared<ghoul::io::TextureReaderCMAP>());
 
-    std::shared_ptr<ScreenSpaceImage> s = std::make_shared<ScreenSpaceImage>();
-    registerScreenSpaceRenderable(s);
+    registerScreenSpaceRenderable(std::make_shared<ScreenSpaceImage>("${OPENSPACE_DATA}/test2.jpg"));
 	return true;
 }
 
@@ -393,7 +392,7 @@ void RenderEngine::render(const glm::mat4 &projectionMatrix, const glm::mat4 &vi
 			renderScreenLog();
 		}
 	}
-
+	
 	for (auto s : _screenSpaceRenderables) {
 		if(s->isEnabled())
 			s->render(_mainCamera);

src/rendering/screenspacerenderable.cpp

@@ -25,12 +25,12 @@
 #include <openspace/rendering/screenspacerenderable.h>
 
 namespace openspace {
-	ScreenSpaceRenderable::ScreenSpaceRenderable()
+	ScreenSpaceRenderable::ScreenSpaceRenderable(std::string texturePath)
 		: _enabled("enabled", "Is Enabled", true)
 		, _flatScreen("flatScreen", "Flat Screen", true)
 		, _position("position", "Position", glm::vec3(0,0,-2),glm::vec3(-2),glm::vec3(2))
 		, _scale("scale", "Scale" , 0.5, 0, 1)
-		, _texturePath("texturePath", "Texture path", "${OPENSPACE_DATA}/test2.jpg")
+		, _texturePath("texturePath", "Texture path", texturePath)
 		, _quad(0)
 		, _vertexPositionBuffer(0)
 	{