Updating Ghoul version

Applying new Ghoul changes

include/openspace/abuffer/abuffer.h

@@ -93,7 +93,7 @@ protected:
 	GLuint _screenQuad;
 
 	bool _validShader;
-	ghoul::opengl::ProgramObject* _resolveShader;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _resolveShader;
 
 	std::vector<std::pair<std::string,ghoul::opengl::Texture*> > _volumes;
 	std::vector<std::pair<std::string,ghoul::opengl::Texture*> > _transferFunctions;

include/openspace/abuffer/abuffervisualizer.h

@@ -60,7 +60,7 @@ private:
 	GLsizei _markersSize;
 	GLuint _imarkers;
 	GLsizei _imarkersSize;
-	ghoul::opengl::ProgramObject* _pointcloudProgram;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _pointcloudProgram;
 
 }; // ABufferVisualizer
 }  // namespace openspace

include/openspace/scene/scene.h

@@ -125,7 +125,7 @@ private:
 
 	std::mutex _programUpdateLock;
 	std::set<ghoul::opengl::ProgramObject*> _programsToUpdate;
-	std::vector<ghoul::opengl::ProgramObject*> _programs;
+    std::vector<std::unique_ptr<ghoul::opengl::ProgramObject>> _programs;
 
     typedef std::map<std::string, ghoul::Dictionary> NodeMap;
     typedef std::multimap<std::string, std::string> DependencyMap;

include/openspace/util/factorymanager.inl

@@ -22,6 +22,8 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
+#include <ghoul/logging/logmanager.h>
+
 namespace openspace {
 
 template <class T>

modules/base/rendering/renderableconstellationbounds.cpp

@@ -138,7 +138,6 @@ bool RenderableConstellationBounds::deinitialize() {
 	glDeleteVertexArrays(1, &_vao);
 	_vao = 0;
 
-	delete _program;
 	_program = nullptr;
 	return true;
 }
@@ -154,7 +153,7 @@ void RenderableConstellationBounds::render(const RenderData& data) {
 	glm::mat4 viewMatrix       = data.camera.viewMatrix();
 	glm::mat4 projectionMatrix = data.camera.projectionMatrix();
 
-	setPscUniforms(_program, &data.camera, data.position);
+	setPscUniforms(_program.get(), &data.camera, data.position);
 
 	_program->setUniform("exponent", _distance);
 	_program->setUniform("ViewProjection", data.camera.viewProjectionMatrix());

modules/base/rendering/renderableconstellationbounds.h

@@ -101,7 +101,7 @@ private:
 	std::string _vertexFilename; ///< The filename containing the constellation bounds
 	std::string _constellationFilename; ///< The file containing constellation names
 
-	ghoul::opengl::ProgramObject* _program;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _program;
 
 	/// The list of all loaded constellation bounds
 	std::vector<ConstellationBound> _constellationBounds;

modules/base/rendering/renderablemodel.cpp

@@ -151,7 +151,6 @@ bool RenderableModel::deinitialize() {
 	}
     _texture = nullptr;
 
-    delete _programObject;
     _programObject = nullptr;
 	return true;
 }
@@ -191,7 +190,7 @@ void RenderableModel::render(const RenderData& data) {
 	_programObject->setUniform("sun_pos", _sunPosition.vec3());
 	_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);
 

modules/base/rendering/renderablemodel.h

@@ -59,7 +59,7 @@ private:
     properties::StringProperty _colorTexturePath;
 	properties::BoolProperty _performFade;
 	properties::FloatProperty _fading;
-    ghoul::opengl::ProgramObject* _programObject; 
+    std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
     std::unique_ptr<ghoul::opengl::Texture> _texture;
 
 	modelgeometry::ModelGeometry* _geometry;

modules/base/rendering/renderablepath.cpp

@@ -29,7 +29,6 @@
 #include <openspace/util/spicemanager.h>
 #include <openspace/util/updatestructures.h>
 #include <ghoul/opengl/programobject.h>
-#include <ghoul/misc/highresclock.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/interaction/interactionhandler.h>
 #include <fstream>
@@ -123,7 +122,6 @@ bool RenderablePath::deinitialize() {
 	glDeleteBuffers(1, &_vBufferID);
     _vBufferID = 0;
 
-    delete _programObject;
     _programObject = nullptr;
 
 	return true;
@@ -158,7 +156,7 @@ void RenderablePath::render(const RenderData& data) {
 	_programObject->setUniform("ModelTransform", transform);
 	_programObject->setUniform("color", _lineColor);
 	_programObject->setUniform("lastPosition", _lastPosition);
-	setPscUniforms(_programObject, &data.camera, data.position);
+	setPscUniforms(_programObject.get(), &data.camera, data.position);
 
 	if (_drawLine) {
 		glLineWidth(_lineWidth);

modules/base/rendering/renderablepath.h

@@ -68,7 +68,7 @@ private:
 	properties::FloatProperty _lineWidth;
 	properties::BoolProperty _drawLine;
 
-	ghoul::opengl::ProgramObject* _programObject;
+	std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
 
 	bool _successfullDictionaryFetch;
 

modules/base/rendering/renderableplane.cpp

@@ -172,7 +172,6 @@ bool RenderablePlane::deinitialize() {
     delete _textureFile;
     _textureFile = nullptr;
 
-    delete _shader;
     _shader = nullptr;
 
 	return true;
@@ -200,7 +199,7 @@ void RenderablePlane::render(const RenderData& data) {
 
 	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
 	_shader->setUniform("ModelTransform", transform);
-	setPscUniforms(_shader, &data.camera, data.position);
+	setPscUniforms(_shader.get(), &data.camera, data.position);
 
 	ghoul::opengl::TextureUnit unit;
 	unit.activate();

modules/base/rendering/renderableplane.h

@@ -76,7 +76,7 @@ private:
 
     bool _planeIsDirty;
 
-	ghoul::opengl::ProgramObject* _shader;
+	std::unique_ptr<ghoul::opengl::ProgramObject> _shader;
     bool _textureIsDirty;
     std::unique_ptr<ghoul::opengl::Texture> _texture;
     ghoul::filesystem::File* _textureFile;

modules/base/rendering/renderablesphere.cpp

@@ -133,7 +133,6 @@ bool RenderableSphere::deinitialize() {
 
     _texture = nullptr;
 
-    delete _shader;
     _shader = nullptr;
 
 	return true;
@@ -152,7 +151,7 @@ void RenderableSphere::render(const RenderData& data) {
 
 	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
 	_shader->setUniform("ModelTransform", transform);
-	setPscUniforms(_shader, &data.camera, data.position);
+	setPscUniforms(_shader.get(), &data.camera, data.position);
 
     _shader->setUniform("alpha", _transparency);
 

modules/base/rendering/renderablesphere.h

@@ -61,7 +61,7 @@ private:
 
     properties::FloatProperty _transparency;
 
-	ghoul::opengl::ProgramObject* _shader;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _shader;
     std::unique_ptr<ghoul::opengl::Texture> _texture;
 
     PowerScaledSphere* _sphere;

modules/base/rendering/renderablestars.cpp

@@ -167,7 +167,6 @@ bool RenderableStars::deinitialize() {
 	_pointSpreadFunctionTexture = nullptr;
     _colorTexture = nullptr;
 
-    delete _program;
 	_program = nullptr;
 	return true;	
 }
@@ -198,7 +197,7 @@ void RenderableStars::render(const RenderData& data) {
     _program->setUniform("scaleFactor", _scaleFactor);
     _program->setUniform("minBillboardSize", _minBillboardSize);
 	
-	setPscUniforms(_program, &data.camera, data.position);
+	setPscUniforms(_program.get(), &data.camera, data.position);
 	_program->setUniform("scaling", scaling);
 
 	ghoul::opengl::TextureUnit psfUnit;

modules/base/rendering/renderablestars.h

@@ -76,7 +76,7 @@ private:
     properties::FloatProperty _scaleFactor;
     properties::FloatProperty _minBillboardSize;
 
-	ghoul::opengl::ProgramObject* _program;
+	std::unique_ptr<ghoul::opengl::ProgramObject> _program;
 
 	std::string _speckFile;
 

modules/base/rendering/renderabletrail.cpp

@@ -29,7 +29,6 @@
 #include <openspace/util/spicemanager.h>
 #include <openspace/util/updatestructures.h>
 #include <ghoul/opengl/programobject.h>
-#include <ghoul/misc/highresclock.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/interaction/interactionhandler.h>
 
@@ -102,10 +101,6 @@ RenderableTrail::RenderableTrail(const ghoul::Dictionary& dictionary)
 	_distanceFade = 1.0;
 }
 
-RenderableTrail::~RenderableTrail() {
-    delete _programObject;
-}
-
 bool RenderableTrail::initialize() {
     if (!_successfullDictionaryFetch) {
         LERROR("The following keys need to be set in the Dictionary. Cannot initialize!");
@@ -149,7 +144,7 @@ void RenderableTrail::render(const RenderData& data) {
     // setup the data to the shader
     _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("color", _lineColor);
     _programObject->setUniform("nVertices", static_cast<unsigned int>(_vertexArray.size()));

modules/base/rendering/renderabletrail.h

@@ -43,7 +43,6 @@ namespace openspace {
 class RenderableTrail : public Renderable {
 public:
     RenderableTrail(const ghoul::Dictionary& dictionary);
-    ~RenderableTrail();
 
     bool initialize() override;
     bool deinitialize() override;
@@ -66,7 +65,7 @@ private:
     properties::FloatProperty _lineWidth;
 	properties::BoolProperty _showTimestamps;
 
-    ghoul::opengl::ProgramObject* _programObject;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
 
     bool _successfullDictionaryFetch;
 

modules/fieldlines/rendering/renderablefieldlines.cpp

@@ -225,7 +225,7 @@ void RenderableFieldlines::render(const RenderData& data) {
 	_program->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
 	_program->setUniform("modelTransform", glm::mat4(1.0));
 	_program->setUniform("cameraViewDir", data.camera.viewDirection());
-	setPscUniforms(_program, &data.camera, data.position);
+	setPscUniforms(_program.get(), &data.camera, data.position);
 
 	_program->setUniform("classification", _classification);
 	if (!_classification)

modules/fieldlines/rendering/renderablefieldlines.h

@@ -75,7 +75,7 @@ private:
 	properties::OptionProperty _seedPointSource;
 	properties::StringProperty _seedPointSourceFile;
 
-	ghoul::opengl::ProgramObject* _program;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _program;
 
 	ghoul::Dictionary _vectorFieldInfo;
 	ghoul::Dictionary _fieldlineInfo;

modules/newhorizons/rendering/renderablecrawlingline.cpp

@@ -129,7 +129,7 @@ void RenderableCrawlingLine::render(const RenderData& data) {
 
         _program->setUniform("_alpha", alpha);
 		_program->setUniform("color", _lineColor);
-	    setPscUniforms(_program, &data.camera, data.position);
+	    setPscUniforms(_program.get(), &data.camera, data.position);
 
 	    glBindVertexArray(_vao);
         glBindBuffer(GL_ARRAY_BUFFER, _vbo);

modules/newhorizons/rendering/renderablecrawlingline.h

@@ -42,7 +42,7 @@ public:
     void update(const UpdateData& data) override;
 
 private:
-    ghoul::opengl::ProgramObject* _program;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _program;
 
     std::string _instrumentName;
     std::string _source;

modules/newhorizons/rendering/renderablefov.cpp

@@ -541,7 +541,7 @@ void RenderableFov::render(const RenderData& data) {
 	// setup the data to the shader
 	_programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
 	_programObject->setUniform("ModelTransform", glm::mat4(1));
-	setPscUniforms(_programObject, &data.camera, data.position);
+	setPscUniforms(_programObject.get(), &data.camera, data.position);
 	
 	if (openspace::ImageSequencer2::ref().isReady())
 		_drawFOV = ImageSequencer2::ref().instrumentActive(_instrumentID);

modules/newhorizons/rendering/renderablefov.h

@@ -56,7 +56,7 @@ public:
     // properties
     properties::FloatProperty _lineWidth;
 	properties::BoolProperty _drawSolid;
-	ghoul::opengl::ProgramObject* _programObject;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
 	ghoul::opengl::Texture* _texture;
 	openspace::SceneGraphNode* _targetNode;
 

modules/newhorizons/rendering/renderablemodelprojection.cpp

@@ -318,7 +318,7 @@ void RenderableModelProjection::render(const RenderData& data) {
 	_viewProjection = data.camera.viewProjectionMatrix();
 	_programObject->setUniform("ViewProjection", _viewProjection);
 	_programObject->setUniform("ModelTransform", _transform);
-	setPscUniforms(_programObject, &data.camera, data.position);
+	setPscUniforms(_programObject.get(), &data.camera, data.position);
 	
 	textureBind();
 	_geometry->render();

modules/newhorizons/rendering/renderablemodelprojection.h

@@ -77,8 +77,8 @@ namespace openspace {
 		properties::IntProperty _rotationY;
 		properties::IntProperty _rotationZ;
 
-		ghoul::opengl::ProgramObject* _programObject;
-		ghoul::opengl::ProgramObject* _fboProgramObject;
+        std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
+        std::unique_ptr<ghoul::opengl::ProgramObject> _fboProgramObject;
 
         std::unique_ptr<ghoul::opengl::Texture> _texture;
         std::unique_ptr<ghoul::opengl::Texture> _textureOriginal;

modules/newhorizons/rendering/renderableplaneprojection.cpp

@@ -141,7 +141,7 @@ void RenderablePlaneProjection::render(const RenderData& data) {
 
 	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
 	_shader->setUniform("ModelTransform", transform);
-	setPscUniforms(_shader, &data.camera, data.position);
+	setPscUniforms(_shader.get(), &data.camera, data.position);
 
 	ghoul::opengl::TextureUnit unit;
 	unit.activate();

modules/newhorizons/rendering/renderableplaneprojection.h

@@ -79,7 +79,7 @@ private:
 	glm::dmat3 _stateMatrix;
 	std::string _frame;
 
-	ghoul::opengl::ProgramObject* _shader;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _shader;
 	bool _textureIsDirty;
     std::unique_ptr<ghoul::opengl::Texture> _texture = nullptr;
 //    ghoul::opengl::Texture* _texture;

modules/newhorizons/rendering/renderableplanetprojection.cpp

@@ -245,10 +245,10 @@ bool RenderablePlanetProjection::initialize() {
             return false;
     }
 
-	if (_fboProgramObject == nullptr)
-		completeSuccess
-		&= OsEng.ref().configurationManager()->getValue("fboPassProgram", _fboProgramObject);
-
+    _fboProgramObject = ghoul::opengl::ProgramObject::Build("fboPassProgram",
+                                      "${SHADERS}/fboPass_vs.glsl",
+                                      "${SHADERS}/fboPass_fs.glsl");
+    
     loadTexture();
 	loadProjectionTexture();
     completeSuccess &= (_texture != nullptr);
@@ -520,7 +520,7 @@ void RenderablePlanetProjection::render(const RenderData& data){
 	_programObject->setUniform("ViewProjection" ,  data.camera.viewProjectionMatrix());
 	_programObject->setUniform("ModelTransform" , _transform);
 	_programObject->setUniform("boresight"    , _boresight);
-	setPscUniforms(_programObject, &data.camera, data.position);
+	setPscUniforms(_programObject.get(), &data.camera, data.position);
 	
 	textureBind();
 	

modules/newhorizons/rendering/renderableplanetprojection.h

@@ -95,8 +95,8 @@ private:
 	properties::BoolProperty _performProjection;
 	properties::BoolProperty _clearAllProjections;
 
-    ghoul::opengl::ProgramObject* _programObject;
-	ghoul::opengl::ProgramObject* _fboProgramObject;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _fboProgramObject;
 
     std::unique_ptr<ghoul::opengl::Texture> _texture;
 	std::unique_ptr<ghoul::opengl::Texture> _textureOriginal;

modules/newhorizons/rendering/renderableshadowcylinder.cpp

@@ -105,7 +105,6 @@ bool RenderableShadowCylinder::deinitialize() {
 	_vao = 0;
 	glDeleteBuffers(1, &_vbo);
 	_vbo = 0;
-	delete _shader;
 	_shader = nullptr;
 	return true;
 }
@@ -122,7 +121,7 @@ void RenderableShadowCylinder::render(const RenderData& data){
 
 	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
 	_shader->setUniform("ModelTransform", _transform);
-	setPscUniforms(_shader, &data.camera, data.position);
+	setPscUniforms(_shader.get(), &data.camera, data.position);
 	
 	glBindVertexArray(_vao);
 	glDrawArrays(GL_TRIANGLE_STRIP, 0, static_cast<GLsizei>(_vertices.size()));

modules/newhorizons/rendering/renderableshadowcylinder.h

@@ -73,7 +73,7 @@ namespace openspace {
 		properties::IntProperty _numberOfPoints;
 		properties::FloatProperty _shadowLength;
 
-		ghoul::opengl::ProgramObject* _shader;
+        std::unique_ptr<ghoul::opengl::ProgramObject> _shader;
 		
 		glm::dmat3 _stateMatrix;
 

modules/onscreengui/src/gui.cpp

@@ -53,7 +53,7 @@ namespace {
 	size_t vboMaxSize = 20000;
 	GLuint vao = 0;
 	GLuint vbo = 0;
-	ghoul::opengl::ProgramObject* _program;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _program;
 
 	static void ImImpl_RenderDrawLists(ImDrawList** const commandLists, int nCommandLists) {
 		if (nCommandLists == 0)
@@ -240,8 +240,6 @@ void GUI::initializeGL() {
 }
 
 void GUI::deinitializeGL() {
-	if (_program)
-		delete _program;
 	_program = nullptr;
 
 	if (vao) glDeleteVertexArrays(1, &vao);

modules/onscreengui/src/guiperformancecomponent.cpp

@@ -87,7 +87,8 @@ void GuiPerformanceComponent::render() {
 			_performanceMemory = new ghoul::SharedMemory(RenderEngine::PerformanceMeasurementSharedData);
 
 
-		PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(_performanceMemory->pointer());
+        void* ptr = _performanceMemory;
+		PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(ptr);
 
 		for (int i = 0; i < layout->nEntries; ++i) {
 			const PerformanceLayout::PerformanceLayoutEntry& entry = layout->entries[i];

src/abuffer/abuffer.cpp

@@ -60,9 +60,7 @@ ABuffer::ABuffer()
 }
 
 ABuffer::~ABuffer() {
-    delete _resolveShader;
-	
-	for (auto file: _samplerFiles)
+	for (auto file : _samplerFiles)
 		delete file;
 }
 
@@ -172,22 +170,17 @@ int ABuffer::addSamplerfile(const std::string& filename) {
 bool ABuffer::updateShader() {
     if (_resolveShader == nullptr)
         return false;
-	bool s = _resolveShader->rebuildFromFile();
-	if (s) {
-		int startAt = 0;
-		for (int i = 0; i < _volumes.size(); ++i) {
-			_resolveShader->setUniform(_volumes.at(i).first, i);
-			startAt = i + 1;
-		}
-		for (int i = 0; i < _transferFunctions.size(); ++i) {
-			_resolveShader->setUniform(_transferFunctions.at(i).first, startAt + i);
-		}
-		LINFO("Successfully updated ABuffer resolve shader!");
-	}
-	else {
-		LWARNING("Couldn't update ABuffer resolve shader");
-	}
-	return s;
+	_resolveShader->rebuildFromFile();
+    int startAt = 0;
+    for (int i = 0; i < _volumes.size(); ++i) {
+        _resolveShader->setUniform(_volumes.at(i).first, i);
+        startAt = i + 1;
+    }
+    for (int i = 0; i < _transferFunctions.size(); ++i) {
+        _resolveShader->setUniform(_transferFunctions.at(i).first, startAt + i);
+    }
+    LINFO("Successfully updated ABuffer resolve shader!");
+	return true;
 }
 
 void ABuffer::generateShaderSource() {

src/abuffer/abuffervisualizer.cpp

@@ -58,8 +58,6 @@ ABufferVisualizer::~ABufferVisualizer() {
 		glDeleteVertexArrays(1, &_pointcloud);
 	if (_markers)
 		glDeleteVertexArrays(1, &_markers);
-	if (_pointcloudProgram)
-		delete _pointcloudProgram;
 }
 
 void ABufferVisualizer::updateData(const std::vector<ABuffer::fragmentData>& data) {

src/interaction/interactionhandler.cpp

@@ -32,7 +32,6 @@
 #include <openspace/util/keys.h>
 
 #include <ghoul/logging/logmanager.h>
-#include <ghoul/misc/highresclock.h>
 #include <ghoul/misc/interpolator.h>
 
 namespace {
@@ -245,9 +244,6 @@ void InteractionHandler::update(double deltaTime) {
 
 	if (_keyframes.size() > 4){	//wait until enough samples are buffered
         hasKeys = true;
-		ghoul::Interpolator<ghoul::Interpolators::CatmullRom> positionInterpCR;
-		ghoul::Interpolator<ghoul::Interpolators::Linear> positionInterpLin;
-		ghoul::Interpolator<ghoul::Interpolators::Linear> quatInterpLin;
         
         openspace::network::datamessagestructures::PositionKeyframe p0, p1, p2, p3;
         
@@ -268,10 +264,10 @@ void InteractionHandler::update(double deltaTime) {
         
         
 		//glm::dvec4 v = positionInterpCR.interpolate(fact, _keyframes[0]._position.dvec4(), _keyframes[1]._position.dvec4(), _keyframes[2]._position.dvec4(), _keyframes[3]._position.dvec4());
-		glm::dvec4 v = positionInterpLin.interpolate(fact, p1._position.dvec4(), p2._position.dvec4());
+        glm::dvec4 v = ghoul::interpolateLinear(fact, p1._position.dvec4(), p2._position.dvec4());
 		
         pos = psc(v.x, v.y, v.z, v.w);
-        q = quatInterpLin.interpolate(fact, p1._viewRotationQuat, p2._viewRotationQuat);
+        q = ghoul::interpolateLinear(fact, p1._viewRotationQuat, p2._viewRotationQuat);
         
         //we're done with this sample interval
         if (_currentKeyframeTime >= p2._timeStamp){

src/interaction/keyboardcontroller.cpp

@@ -32,7 +32,8 @@
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/lua/ghoul_lua.h>
-#include <ghoul/misc/highresclock.h>
+
+#include <chrono>
 
 namespace {
 	const std::string _loggerCat = "KeyboardController";
@@ -169,7 +170,7 @@ void KeyboardControllerLua::keyPressed(KeyAction action, Key key, KeyModifier mo
 		return;
 	}
 
-	auto start = ghoul::HighResClock::now();
+    auto start = std::chrono::high_resolution_clock::now();
 
 	lua_getfield(s, -1, keyToString(key, modifier).c_str());
 	if (!lua_isnil(s, -1))
@@ -177,7 +178,7 @@ void KeyboardControllerLua::keyPressed(KeyAction action, Key key, KeyModifier mo
 	else
 		LINFO("Key not found");
 
-	auto end = ghoul::HighResClock::now();
+    auto end = std::chrono::high_resolution_clock::now();
 	LINFO("Keyboard timing: " << std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() << "ns");
 
 

src/rendering/renderengine.cpp

@@ -919,7 +919,8 @@ void RenderEngine::storePerformanceMeasurements() {
 		ghoul::SharedMemory::create(PerformanceMeasurementSharedData, totalSize);
 		_performanceMemory = new ghoul::SharedMemory(PerformanceMeasurementSharedData);
 
-		PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(_performanceMemory->pointer());
+        void* ptr = _performanceMemory;
+		PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(ptr);
 		layout->version = Version;
 		layout->nValuesPerEntry = nValues;
 		layout->nEntries = nNodes;
@@ -944,7 +945,8 @@ void RenderEngine::storePerformanceMeasurements() {
 		}
 	}
 
-	PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(_performanceMemory->pointer());
+    void* ptr = _performanceMemory;
+	PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(ptr);
 	_performanceMemory->acquireLock();
 	for (int i = 0; i < nNodes; ++i) {
 		SceneGraphNode* node = scene()->allSceneGraphNodes()[i];

src/scene/scene.cpp

@@ -84,8 +84,6 @@ bool Scene::initialize() {
     using ghoul::opengl::ShaderObject;
     using ghoul::opengl::ProgramObject;
 
-    ProgramObject* tmpProgram;
-
 	ghoul::opengl::ProgramObject::ProgramObjectCallback cb = [this](ghoul::opengl::ProgramObject* program) {
 		_programUpdateLock.lock();
 		_programsToUpdate.insert(program);
@@ -93,40 +91,40 @@ bool Scene::initialize() {
 	};
 
 	// fboPassthrough program
-	tmpProgram = ProgramObject::Build("fboPassProgram",
+	std::unique_ptr<ghoul::opengl::ProgramObject> prg = ProgramObject::Build("fboPassProgram",
 		"${SHADERS}/fboPass_vs.glsl",
 		"${SHADERS}/fboPass_fs.glsl");
-	if (!tmpProgram) return false;
-	tmpProgram->setProgramObjectCallback(cb);
-	_programs.push_back(tmpProgram);
-	OsEng.ref().configurationManager()->setValue("fboPassProgram", tmpProgram);
+	if (!prg) return false;
+	prg->setProgramObjectCallback(cb);
+    OsEng.ref().configurationManager()->setValue("fboPassProgram", prg.get());
+    _programs.push_back(std::move(prg));
 
 	// pscstandard
-	tmpProgram = ProgramObject::Build("pscstandard",
+	prg = ProgramObject::Build("pscstandard",
 		"${SHADERS}/pscstandard_vs.glsl",
 		"${SHADERS}/pscstandard_fs.glsl");
-    if( ! tmpProgram) return false;
-	tmpProgram->setProgramObjectCallback(cb);
-	_programs.push_back(tmpProgram);
-    OsEng.ref().configurationManager()->setValue("pscShader", tmpProgram);
+    if (! prg) return false;
+	prg->setProgramObjectCallback(cb);
+    OsEng.ref().configurationManager()->setValue("pscShader", prg.get());
+    _programs.push_back(std::move(prg));
 
 	// Night texture program
-	tmpProgram = ProgramObject::Build("nightTextureProgram",
+	prg = ProgramObject::Build("nightTextureProgram",
 		"${SHADERS}/nighttexture_vs.glsl",
 		"${SHADERS}/nighttexture_fs.glsl");
-	if (!tmpProgram) return false;
-	tmpProgram->setProgramObjectCallback(cb);
-	_programs.push_back(tmpProgram);
-	OsEng.ref().configurationManager()->setValue("nightTextureProgram", tmpProgram);
+	if (!prg) return false;
+	prg->setProgramObjectCallback(cb);
+    OsEng.ref().configurationManager()->setValue("nightTextureProgram", prg.get());
+    _programs.push_back(std::move(prg));
 
     // RaycastProgram
-	tmpProgram = ProgramObject::Build("RaycastProgram",
+	prg = ProgramObject::Build("RaycastProgram",
 		"${SHADERS}/exitpoints.vert",
 		"${SHADERS}/exitpoints.frag");
-	if (!tmpProgram) return false;
-	tmpProgram->setProgramObjectCallback(cb);
-	_programs.push_back(tmpProgram);
-    OsEng.ref().configurationManager()->setValue("RaycastProgram", tmpProgram);
+	if (!prg) return false;
+	prg->setProgramObjectCallback(cb);
+    OsEng.ref().configurationManager()->setValue("RaycastProgram", prg.get());
+    _programs.push_back(std::move(prg));
 
     return true;
 }
@@ -136,8 +134,6 @@ bool Scene::deinitialize() {
 
 	// clean up all programs
 	_programsToUpdate.clear();
-	for (ghoul::opengl::ProgramObject* program : _programs)
-		delete program;
 	_programs.clear();
     return true;
 }
@@ -175,7 +171,7 @@ void Scene::render(const RenderData& data) {
 	if (!emptyProgramsToUpdate) {
 		LDEBUG("Setting uniforms");
 		// Ignore attribute locations
-		for (ghoul::opengl::ProgramObject* program : _programs)
+		for (const auto& program : _programs)
 			program->setIgnoreSubroutineUniformLocationError(true);
 	}
 

src/scene/scenegraphnode.cpp

@@ -34,7 +34,6 @@
 #include <ghoul/opengl/shadermanager.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/opengl/shaderobject.h>
-#include <ghoul/misc/highresclock.h>
 
 #include <modules/base/ephemeris/staticephemeris.h>
 #include <openspace/engine/openspaceengine.h>
@@ -43,6 +42,7 @@
 #include <boost/algorithm/string.hpp>
 
 #include <cctype>
+#include <chrono>
 
 namespace {
     const std::string _loggerCat = "SceneGraphNode";
@@ -177,12 +177,12 @@ void SceneGraphNode::update(const UpdateData& data) {
 	if (_ephemeris) {
 		if (data.doPerformanceMeasurement) {
 			glFinish();
-			ghoul::HighResClock::time_point start = ghoul::HighResClock::now();
+            auto start = std::chrono::high_resolution_clock::now();
 
 			_ephemeris->update(data);
 
 			glFinish();
-			ghoul::HighResClock::time_point end = ghoul::HighResClock::now();
+			auto end = std::chrono::high_resolution_clock::now();
 			_performanceRecord.updateTimeEphemeris = (end - start).count();
 		}
 		else
@@ -192,12 +192,12 @@ void SceneGraphNode::update(const UpdateData& data) {
 	if (_renderable && _renderable->isReady()) {
 		if (data.doPerformanceMeasurement) {
 			glFinish();
-			ghoul::HighResClock::time_point start = ghoul::HighResClock::now();
+			auto start = std::chrono::high_resolution_clock::now();
 
 			_renderable->update(data);
 
 			glFinish();
-			ghoul::HighResClock::time_point end = ghoul::HighResClock::now();
+			auto end = std::chrono::high_resolution_clock::now();
 			_performanceRecord.updateTimeRenderable = (end - start).count();
 		}
 		else
@@ -254,12 +254,12 @@ void SceneGraphNode::render(const RenderData& data) {
     if (_renderableVisible && _renderable->isVisible() && _renderable->isReady() && _renderable->isEnabled()) {
 		if (data.doPerformanceMeasurement) {
 			glFinish();
-			ghoul::HighResClock::time_point start = ghoul::HighResClock::now();
+			auto start = std::chrono::high_resolution_clock::now();
 
 			_renderable->render(newData);
 
 			glFinish();
-			ghoul::HighResClock::time_point end = ghoul::HighResClock::now();
+			auto end = std::chrono::high_resolution_clock::now();
 			_performanceRecord.renderTime = (end - start).count();
 		}
 		else