solved merge conflict

include/openspace/rendering/renderengine.h

@@ -138,6 +138,7 @@ public:
 	// Temporary fade functionality
 	void startFading(int direction, float fadeDuration);
 
+    void sortScreenspaceRenderables();
     // This is temporary until a proper screenspace solution is found ---abock
     struct {
         glm::vec2 _position;

include/openspace/rendering/screenspacerenderable.h

@@ -55,8 +55,11 @@ public:
 	virtual void update() = 0;
 	virtual bool isReady() const = 0;
 	bool isEnabled() const;
+	
 	glm::vec2 euclideanPosition() const {return _euclideanPosition.value();};
 	glm::vec2 sphericalPosition() const {return _sphericalPosition.value();};
+	float depth() const {return _depth.value();};
+	
 	void move(glm::vec2 v){
 		if(_useFlatScreen.value()){
 			glm::vec2 pos = _euclideanPosition.value();

modules/base/rendering/screenspaceframebuffer.cpp

@@ -34,11 +34,18 @@
 namespace openspace {
 ScreenSpaceFramebuffer::ScreenSpaceFramebuffer() 
 	:ScreenSpaceRenderable()
+	,_size("size", "Size", glm::vec4(0), glm::vec4(0), glm::vec4(2000))
 	,_framebuffer(nullptr)
 {
 	_id = id();
 	setName("ScreenSpaceFramebuffer" + std::to_string(_id));
 	registerProperties();
+	glm::vec2 resolution = OsEng.windowWrapper().currentWindowResolution();
+
+	addProperty(_size);
+	OsEng.gui()._property.registerProperty(&_size);
+	_size.set(glm::vec4(0, 0, resolution.x,resolution.y));
+
 }
 
 ScreenSpaceFramebuffer::~ScreenSpaceFramebuffer(){}
@@ -76,18 +83,26 @@ bool ScreenSpaceFramebuffer::deinitialize(){
 
     _framebuffer->detachAll();
 
+    removeAllRenderFunctions();
+
 	return true;
 }
 
 void ScreenSpaceFramebuffer::render(){
+	glm::vec2 resolution = OsEng.windowWrapper().currentWindowResolution();
+	glm::vec4 size = _size.value();
+
+	float xratio = _originalViewportSize.x / (size.z-size.x);
+	float yratio = _originalViewportSize.y / (size.w-size.y);;
+
 	if(!_renderFunctions.empty()){
-		glViewport (0, 0, _originalViewportSize.x, _originalViewportSize.y);
+		glViewport (-size.x*xratio, -size.y*yratio, _originalViewportSize.x*xratio, _originalViewportSize.y*yratio);
 		GLint defaultFBO = _framebuffer->getActiveObject();
 		_framebuffer->activate();
 		
 		glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
 		glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
+		glEnable(GL_ALPHA_TEST);
 		for(auto renderFunction : _renderFunctions){
 
 			(*renderFunction)();
@@ -96,13 +111,13 @@ void ScreenSpaceFramebuffer::render(){
 		_framebuffer->deactivate();
 
 		glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
-		glm::vec2 resolution = OsEng.windowWrapper().currentWindowResolution();
+		
 		glViewport (0, 0, resolution.x, resolution.y);
 		
 		glm::mat4 rotation = rotationMatrix();
 		glm::mat4 translation = translationMatrix();
 		glm::mat4 scale = scaleMatrix();
-		scale = glm::scale(scale, glm::vec3(1.0f, -1.0f, 1.0f));
+		scale = glm::scale(scale, glm::vec3((1.0/xratio), -(1.0/yratio), 1.0f));
 		glm::mat4 modelTransform = rotation*translation*scale;
 		draw(modelTransform);
 	}
@@ -143,7 +158,15 @@ void ScreenSpaceFramebuffer::createFragmentbuffer(){
 	// glDrawBuffers(1, DrawBuffers);
 }
 
+void ScreenSpaceFramebuffer::setSize(glm::vec4 size){
+	_size.set(size);
+}
+
 void ScreenSpaceFramebuffer::addRenderFunction(std::shared_ptr<std::function<void()>> renderFunction){
 	_renderFunctions.push_back(renderFunction);
 }
+
+void ScreenSpaceFramebuffer::removeAllRenderFunctions(){
+	_renderFunctions.clear();
+}
 } //namespace openspace

modules/base/rendering/screenspaceframebuffer.h

@@ -41,15 +41,21 @@ public:
 	void render() override;
 	void update() override;
 	bool isReady() const override;
+
+	void setSize(glm::vec4);
 	void addRenderFunction(std::shared_ptr<std::function<void()>> renderFunction);
+	void removeAllRenderFunctions();
 private:
 	void createFragmentbuffer();
 	static int id();
 
 	std::unique_ptr<ghoul::opengl::FramebufferObject> _framebuffer;
+
 	int _id;
 
 	std::vector<std::shared_ptr<std::function<void()>>> _renderFunctions;
+	properties::Vec4Property _size;
+
 };
 
 } //namespace openspace

src/rendering/renderengine.cpp

@@ -96,6 +96,7 @@ namespace {
     const std::string RenderFsPath = "${SHADERS}/render.frag";
 }
 
+
 namespace openspace {
 
 const std::string RenderEngine::PerformanceMeasurementSharedData =
@@ -207,15 +208,18 @@ bool RenderEngine::initialize() {
   
     ghoul::io::TextureReader::ref().addReader(std::make_shared<ghoul::io::TextureReaderCMAP>());
 
+    //For testing screenspacerenderables
+
+
     std::shared_ptr<ScreenSpaceFramebuffer> ssfb = std::make_shared<ScreenSpaceFramebuffer>();
     ssfb->addRenderFunction(std::make_shared<std::function<void()>>([this](){renderInformation();}));
     ssfb->addRenderFunction(std::make_shared<std::function<void()>>([this](){ssr->render();}));
     registerScreenSpaceRenderable(ssfb);
-    //For testing screenspacerenderables
+
+
     ssr = std::make_shared<ScreenSpaceImage>("${OPENSPACE_DATA}/test2.jpg");
     registerScreenSpaceRenderable(ssr);
 
-
 	return true;
 }
 
@@ -1467,4 +1471,11 @@ void RenderEngine::renderScreenLog() {
 	}
 }
 
+void RenderEngine::sortScreenspaceRenderables(){
+	std::sort(_screenSpaceRenderables.begin(), _screenSpaceRenderables.end(),
+			  [](std::shared_ptr<ScreenSpaceRenderable> j, std::shared_ptr<ScreenSpaceRenderable> i){
+			  	return i->depth() > j->depth();
+			  });
+}
+
 }// namespace openspace

src/rendering/screenspacerenderable.cpp

@@ -30,7 +30,7 @@ ScreenSpaceRenderable::ScreenSpaceRenderable()
 	, _useFlatScreen("flatScreen", "Flat Screen", false)
 	, _euclideanPosition("euclideanPosition", "Euclidean coordinates", glm::vec2(0),glm::vec2(-4),glm::vec2(4))
 	, _sphericalPosition("sphericalPosition", "Spherical coordinates", glm::vec2(0),glm::vec2(-M_PI),glm::vec2(M_PI))
-	, _depth("depth", "Depth", 0, 0, 1)
+	, _depth("depth", "Depth", 0, 0, 0)
 	, _scale("scale", "Scale" , 0.5, 0, 2)
 	, _alpha("alpha", "Alpha" , 1, 0, 1)
 	, _quad(0)
@@ -58,6 +58,7 @@ ScreenSpaceRenderable::ScreenSpaceRenderable()
     _radius = _planeDepth;
 
     _sphericalPosition.set(toSpherical(_euclideanPosition.value()));
+
 }
 
 ScreenSpaceRenderable::~ScreenSpaceRenderable(){}