Merge with antialiased abuffer

modules/base/rendering/renderableconstellationbounds.cpp

@@ -23,6 +23,8 @@
  ****************************************************************************************/
 
 // openspace
+#include <openspace/engine/openspaceengine.h>
+#include <openspace/rendering/renderengine.h>
 #include <modules/base/rendering/renderableconstellationbounds.h>
 #include <openspace/util/spicemanager.h>
 #include <openspace/util/updatestructures.h>
@@ -90,9 +92,11 @@ RenderableConstellationBounds::~RenderableConstellationBounds() {
 }
 
 bool RenderableConstellationBounds::initialize() {
-	_program = ghoul::opengl::ProgramObject::Build("ConstellationBounds",
-		"${MODULE_BASE}/shaders/constellationbounds_vs.glsl",
-		"${MODULE_BASE}/shaders/constellationbounds_fs.glsl");
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    _program = renderEngine.buildRenderProgram("ConstellationBounds",
+        "${MODULE_BASE}/shaders/constellationbounds_vs.glsl",
+        "${MODULE_BASE}/shaders/constellationbounds_fs.glsl");
+
 	if (!_program)
 		return false;
 
@@ -138,7 +142,12 @@ bool RenderableConstellationBounds::deinitialize() {
 	glDeleteVertexArrays(1, &_vao);
 	_vao = 0;
 
-	_program = nullptr;
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_program) {
+        renderEngine.removeRenderProgram(_program);
+        _program = nullptr;
+    }
+
 	return true;
 }
 
@@ -175,9 +184,6 @@ void RenderableConstellationBounds::render(const RenderData& data) {
 }
 
 void RenderableConstellationBounds::update(const UpdateData& data) {
-	if (_program->isDirty())
-		_program->rebuildFromFile();
-
     _stateMatrix = SpiceManager::ref().positionTransformMatrix(
 		_originReferenceFrame,
 		"GALACTIC",

modules/base/rendering/renderablemodel.cpp

@@ -26,6 +26,7 @@
 //                     ie after I see model on screen)
 
 // open space includes
+#include <openspace/rendering/renderengine.h>
 #include <modules/base/rendering/renderablemodel.h>
 #include <modules/base/rendering/modelgeometry.h>
 #include <openspace/engine/configurationmanager.h>
@@ -126,9 +127,12 @@ bool RenderableModel::initialize() {
     bool completeSuccess = true;
     if (_programObject == nullptr) {
         // NH shader
-        _programObject = ghoul::opengl::ProgramObject::Build("ModelProgram",
+
+        RenderEngine& renderEngine = OsEng.renderEngine();
+        _programObject = renderEngine.buildRenderProgram("ModelProgram",
             "${MODULE_BASE}/shaders/model_vs.glsl",
             "${MODULE_BASE}/shaders/model_fs.glsl");
+
         if (!_programObject)
             return false;
     }
@@ -151,7 +155,13 @@ bool RenderableModel::deinitialize() {
 	}
     _texture = nullptr;
 
-    _programObject = nullptr;
+
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_programObject) {
+        renderEngine.removeRenderProgram(_programObject);
+        _programObject = nullptr;
+    }
+
 	return true;
 }
 

modules/base/rendering/renderablepath.cpp

@@ -29,6 +29,7 @@
 #include <openspace/util/updatestructures.h>
 #include <ghoul/opengl/programobject.h>
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/rendering/renderengine.h>
 #include <openspace/interaction/interactionhandler.h>
 #include <fstream>
 
@@ -97,10 +98,12 @@ bool RenderablePath::initialize() {
 	}
 
 	bool completeSuccess = true;
-	_programObject = ghoul::opengl::ProgramObject::Build("PathProgram",
-		"${MODULE_BASE}/shaders/path_vs.glsl",
-		"${MODULE_BASE}/shaders/path_fs.glsl"
-		);
+
+
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    _programObject = renderEngine.buildRenderProgram("PathProgram",
+        "${MODULE_BASE}/shaders/path_vs.glsl",
+        "${MODULE_BASE}/shaders/path_fs.glsl");
 	if (!_programObject)
 		return false;
 
@@ -121,7 +124,11 @@ bool RenderablePath::deinitialize() {
 	glDeleteBuffers(1, &_vBufferID);
     _vBufferID = 0;
 
-    _programObject = nullptr;
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_programObject) {
+        renderEngine.removeRenderProgram(_programObject);
+        _programObject = nullptr;
+    }
 
 	return true;
 }

modules/base/rendering/renderableplane.cpp

@@ -143,9 +143,12 @@ bool RenderablePlane::initialize() {
 
 	if (_shader == nullptr) {
         // Plane Program
-        _shader = ghoul::opengl::ProgramObject::Build("PlaneProgram",
+
+        RenderEngine& renderEngine = OsEng.renderEngine();
+        _shader = renderEngine.buildRenderProgram("PlaneProgram",
             "${MODULE_BASE}/shaders/plane_vs.glsl",
-            "${MODULE_BASE}/shaders/plane_fs.glsl");
+            "${MODULE_BASE}/shaders/plane_fs.glsl"
+            );
         if (!_shader)
             return false;
     }
@@ -171,7 +174,12 @@ bool RenderablePlane::deinitialize() {
     delete _textureFile;
     _textureFile = nullptr;
 
-    _shader = nullptr;
+
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_shader) {
+        renderEngine.removeRenderProgram(_shader);
+        _shader = nullptr;
+    }
 
 	return true;
 }

modules/base/rendering/renderableplanet.cpp

@@ -27,6 +27,7 @@
 
 #include <openspace/engine/configurationmanager.h>
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/rendering/renderengine.h>
 #include <modules/base/rendering/planetgeometry.h>
 #include <openspace/util/time.h>
 #include <openspace/util/spicemanager.h>
@@ -122,10 +123,25 @@ RenderablePlanet::~RenderablePlanet() {
 }
 
 bool RenderablePlanet::initialize() {
-    if (_programObject == nullptr && _hasNightTexture)
-		OsEng.ref().configurationManager().getValue("nightTextureProgram", _programObject);
-	else if (_programObject == nullptr)
-		OsEng.ref().configurationManager().getValue("pscShader", _programObject);
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_programObject == nullptr && _hasNightTexture) {
+        // Night texture program
+        _programObject = renderEngine.buildRenderProgram(
+            "nightTextureProgram",
+            "${SHADERS}/nighttexture_vs.glsl",
+            "${SHADERS}/nighttexture_fs.glsl");
+        if (!_programObject) return false;
+    }
+    else if (_programObject == nullptr) {
+        // pscstandard
+        _programObject = renderEngine.buildRenderProgram(
+            "pscstandard",
+            "${SHADERS}/pscstandard_vs.glsl",
+            "${SHADERS}/pscstandard_fs.glsl");
+        if (!_programObject) return false;
+
+    }
+    _programObject->setIgnoreSubroutineUniformLocationError(true);
 
     loadTexture();
     _geometry->initialize(this);
@@ -139,6 +155,12 @@ bool RenderablePlanet::deinitialize() {
         delete _geometry;
     }
 
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_programObject) {
+        renderEngine.removeRenderProgram(_programObject);
+        _programObject = nullptr;
+    }
+
     _geometry = nullptr;
     _texture = nullptr;
 	_nightTexture = nullptr;
@@ -187,7 +209,7 @@ void RenderablePlanet::render(const RenderData& data)
 	_programObject->setUniform("transparency", _alpha);
 	_programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
 	_programObject->setUniform("ModelTransform", transform);
-	setPscUniforms(_programObject, &data.camera, data.position);
+	setPscUniforms(_programObject.get(), &data.camera, data.position);
 	
     _programObject->setUniform("_performShading", _performShading);
 
@@ -204,6 +226,10 @@ void RenderablePlanet::render(const RenderData& data)
 		_nightTexture->bind();
 		_programObject->setUniform("nightTex", nightUnit);
 	}
+
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK);
+
     // render
     _geometry->render();
 

modules/base/rendering/renderableplanet.h

@@ -62,7 +62,7 @@ protected:
 
 private:
     properties::StringProperty _colorTexturePath;
-    ghoul::opengl::ProgramObject* _programObject;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
     std::unique_ptr<ghoul::opengl::Texture> _texture;
     std::unique_ptr<ghoul::opengl::Texture> _nightTexture;
     planetgeometry::PlanetGeometry* _geometry;

modules/base/rendering/renderablesphere.cpp

@@ -22,9 +22,11 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
+
 #include <modules/base/rendering/renderablesphere.h>
 
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/rendering/renderengine.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/textureunit.h>
 #include <ghoul/filesystem/filesystem.h>
@@ -115,7 +117,8 @@ bool RenderableSphere::initialize() {
     _sphere->initialize();
 
     // pscstandard
-    _shader = ghoul::opengl::ProgramObject::Build("Sphere",
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    _shader = renderEngine.buildRenderProgram("Sphere",
         "${MODULES}/base/shaders/sphere_vs.glsl",
         "${MODULES}/base/shaders/sphere_fs.glsl");
     if (!_shader)
@@ -132,7 +135,12 @@ bool RenderableSphere::deinitialize() {
 
     _texture = nullptr;
 
-    _shader = nullptr;
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_shader) {
+        renderEngine.removeRenderProgram(_shader);
+        _shader = nullptr;
+    }
+
 
 	return true;
 }
@@ -150,8 +158,8 @@ void RenderableSphere::render(const RenderData& data) {
 
 	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
 	_shader->setUniform("ModelTransform", transform);
-	setPscUniforms(_shader.get(), &data.camera, data.position);
 
+	setPscUniforms(_shader.get(), &data.camera, data.position);
     _shader->setUniform("alpha", _transparency);
 
 	ghoul::opengl::TextureUnit unit;
@@ -159,6 +167,9 @@ void RenderableSphere::render(const RenderData& data) {
 	_texture->bind();
 	_shader->setUniform("texture1", unit);
 
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK);
+
     _sphere->render();
 
     _shader->setIgnoreUniformLocationError(false);

modules/base/rendering/renderablestars.cpp

@@ -25,6 +25,8 @@
 #include <modules/base/rendering/renderablestars.h>
 
 #include <openspace/util/updatestructures.h>
+#include <openspace/engine/openspaceengine.h>
+#include <openspace/rendering/renderengine.h>
 
 #include <ghoul/filesystem/filesystem>
 #include <ghoul/misc/templatefactory.h>
@@ -90,8 +92,8 @@ RenderableStars::RenderableStars(const ghoul::Dictionary& dictionary)
 	, _colorTextureIsDirty(true)
 	, _colorOption("colorOption", "Color Option")
 	, _dataIsDirty(true)
-    , _scaleFactor("scaleFactor", "Scale Factor", 5.f, 0.f, 10.f)
-    , _minBillboardSize("minBillboardSize", "Min Billboard Size", 15.f, 1.f, 100.f)
+    , _scaleFactor("scaleFactor", "Scale Factor", 1.f, 0.f, 10.f)
+    , _minBillboardSize("minBillboardSize", "Min Billboard Size", 1.f, 1.f, 100.f)
 	, _program(nullptr)
 	, _speckFile("")
 	, _nValuesPerStar(0)
@@ -146,11 +148,12 @@ bool RenderableStars::isReady() const {
 bool RenderableStars::initialize() {
 	bool completeSuccess = true;
 
-	_program = ghoul::opengl::ProgramObject::Build("Star",
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    _program = renderEngine.buildRenderProgram("Star",
 		"${MODULE_BASE}/shaders/star_vs.glsl",
 		"${MODULE_BASE}/shaders/star_fs.glsl",
 		"${MODULE_BASE}/shaders/star_ge.glsl");
-    
+
 	if (!_program)
 		return false;
 	completeSuccess &= loadData();
@@ -166,17 +169,18 @@ bool RenderableStars::deinitialize() {
 	_vao = 0;
 
 	_pointSpreadFunctionTexture = nullptr;
-    _colorTexture = nullptr;
+	_colorTexture = nullptr;
 
-	_program = nullptr;
-	return true;	
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_program) {
+        renderEngine.removeRenderProgram(_program);
+        _program = nullptr;
+    }
+    return true;
 }
 
 void RenderableStars::render(const RenderData& data) {
-    //glEnable(GL_BLEND);
-    //glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
-    glDisable(GL_DEPTH_TEST);
-    
+    glDepthMask(false);
 	_program->activate();
 
 	// @Check overwriting the scaling from the camera; error as parsec->meter conversion
@@ -221,16 +225,10 @@ void RenderableStars::render(const RenderData& data) {
 	_program->setIgnoreUniformLocationError(false);
 	_program->deactivate();
     
-    //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    glEnable(GL_DEPTH_TEST);
+	glDepthMask(true);
 }
 
 void RenderableStars::update(const UpdateData& data) {
-	if (_program->isDirty()) {
-		_program->rebuildFromFile();
-		_dataIsDirty = true;
-	}
-	
 	if (_dataIsDirty) {
 		const int value = _colorOption;
 		LDEBUG("Regenerating data");

modules/base/rendering/renderabletrail.cpp

@@ -29,6 +29,7 @@
 #include <openspace/util/updatestructures.h>
 #include <ghoul/opengl/programobject.h>
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/rendering/renderengine.h>
 #include <openspace/interaction/interactionhandler.h>
 
 #include <limits>
@@ -113,9 +114,13 @@ bool RenderableTrail::initialize() {
     }
 
     bool completeSuccess = true;
-    _programObject = ghoul::opengl::ProgramObject::Build("EphemerisProgram",
+
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    _programObject = renderEngine.buildRenderProgram("EphemerisProgram",
         "${MODULE_BASE}/shaders/ephemeris_vs.glsl",
         "${MODULE_BASE}/shaders/ephemeris_fs.glsl");
+
+
     if (!_programObject)
         return false;
 
@@ -125,6 +130,13 @@ bool RenderableTrail::initialize() {
 bool RenderableTrail::deinitialize() {
     glDeleteVertexArrays(1, &_vaoID);
     glDeleteBuffers(1, &_vBufferID);
+
+    RenderEngine& renderEngine = OsEng.renderEngine();
+    if (_programObject) {
+        renderEngine.removeRenderProgram(_programObject);
+        _programObject = nullptr;
+    }
+    
     return true;
 }
 
@@ -192,8 +204,6 @@ void RenderableTrail::update(const UpdateData& data) {
         return;
     }
 
-    if (_programObject->isDirty())
-        _programObject->rebuildFromFile();
     double lightTime = 0.0;
 
 	bool intervalSet = hasTimeInterval();