Replaced RuntimeData with separate, temporary structs that are passed around

src/engine/openspaceengine.cpp

@@ -24,10 +24,6 @@
 
 #include <openspace/engine/openspaceengine.h>
 
-// sgct header has to be included before all others due to Windows header
-#define SGCT_WINDOWS_INCLUDE
-#include "sgct.h"
-
 #include <openspace/interaction/deviceidentifier.h>
 #include <openspace/interaction/interactionhandler.h>
 #include <openspace/rendering/renderengine.h>
@@ -37,7 +33,6 @@
 #include <openspace/util/spicemanager.h>
 #include <openspace/util/factorymanager.h>
 #include <openspace/util/constants.h>
-#include <openspace/util/runtimedata.h>
 #include <openspace/util/spicemanager.h>
 
 #include <ghoul/filesystem/filesystem.h>
@@ -329,9 +324,6 @@ bool OpenSpaceEngine::initialize()
     Spice::init();
     Spice::ref().loadDefaultKernels(); // changeto: instantiate spicemanager, load kernels. 
 
-	RuntimeData* initialData = new RuntimeData;
-	initialData->setTime(Time::ref().currentTime());
-	
 	SpiceManager::ref().loadKernel(absPath("${OPENSPACE_DATA}/spice/de430_1850-2150.bsp"), "SPK_EARTH");
 	SpiceManager::ref().loadKernel(absPath("${OPENSPACE_DATA}/spice/MAR063.bsp")         , "SPK_MARS");
 	SpiceManager::ref().loadKernel(absPath("${OPENSPACE_DATA}/spice/pck00010.tpc")       , "PCK");
@@ -355,8 +347,6 @@ bool OpenSpaceEngine::initialize()
 
     // initialize the RenderEngine, needs ${SCENEPATH} to be set
     _renderEngine->initialize();
-	_renderEngine->setRuntimeData(initialData);
-	sceneGraph->setRuntimeData(initialData);
 	sceneGraph->initialize();
 
     std::string sceneDescriptionPath;

src/rendering/planets/renderableplanet.cpp

@@ -113,7 +113,7 @@ bool RenderablePlanet::deinitialize()
     return true;
 }
 
-void RenderablePlanet::render(const Camera* camera, const psc& thisPosition, RuntimeData* runtimeData)
+void RenderablePlanet::render(const RenderData& data)
 {
 	if (!_programObject)
 		return;
@@ -124,9 +124,9 @@ void RenderablePlanet::render(const Camera* camera, const psc& thisPosition, Run
     _programObject->activate();
 
     // fetch data
-    psc currentPosition = thisPosition;
-	psc campos          = camera->position();
-    glm::mat4 camrot    = camera->viewRotationMatrix();
+    psc currentPosition = data.position;
+	psc campos          = data.camera.position();
+    glm::mat4 camrot    = data.camera.viewRotationMatrix();
    // PowerScaledScalar scaling = camera->scaling();
 
     PowerScaledScalar scaling = glm::vec2(1, -6);
@@ -134,23 +134,19 @@ void RenderablePlanet::render(const Camera* camera, const psc& thisPosition, Run
     // scale the planet to appropriate size since the planet is a unit sphere
     glm::mat4 transform = glm::mat4(1);
 	
-	// set spice-orientation in accordance to timestamp
-	glm::dmat3 stateMatrix;
-	openspace::SpiceManager::ref().getPositionTransformMatrixGLM("GALACTIC", "IAU_EARTH", runtimeData->getTime(), stateMatrix);
-	
 	//earth needs to be rotated for that to work.
 	glm::mat4 rot = glm::rotate(transform, 90.f, glm::vec3(1, 0, 0));
 		
 	for (int i = 0; i < 3; i++){
 		for (int j = 0; j < 3; j++){
-			transform[i][j] = stateMatrix[i][j];
+			transform[i][j] = _stateMatrix[i][j];
 		}
 	}
 	transform = transform* rot;
 	
 
     // setup the data to the shader
-    _programObject->setUniform("ViewProjection", camera->viewProjectionMatrix());
+    _programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
     _programObject->setUniform("ModelTransform", transform);
     _programObject->setUniform("campos", campos.vec4());
     _programObject->setUniform("objpos", currentPosition.vec4());
@@ -171,8 +167,11 @@ void RenderablePlanet::render(const Camera* camera, const psc& thisPosition, Run
 
 }
 
-void RenderablePlanet::update()
+void RenderablePlanet::update(const UpdateData& data)
 {
+	// set spice-orientation in accordance to timestamp
+	openspace::SpiceManager::ref().getPositionTransformMatrixGLM("GALACTIC", "IAU_EARTH", data.time, _stateMatrix);
+
 }
 
 void RenderablePlanet::loadTexture()

src/rendering/renderable.cpp

@@ -88,7 +88,7 @@ const PowerScaledScalar& Renderable::getBoundingSphere()
     return boundingSphere_;
 }
 
-void Renderable::update()
+void Renderable::update(const UpdateData&)
 {
 }
 

src/rendering/renderablefieldlines.cpp

@@ -211,29 +211,29 @@ bool RenderableFieldlines::deinitialize() {
 	return true;
 }
 
-void RenderableFieldlines::render(const Camera* camera, const psc& thisPosition, RuntimeData* runtimeData) {
+void RenderableFieldlines::render(const RenderData& data) {
 	if(_update) {
 		_update = false;
 		safeShaderCompilation();
 	}
 
-	glm::mat4 transform = camera->viewProjectionMatrix();
-	glm::mat4 camTransform = camera->viewRotationMatrix();
-	psc relative = thisPosition-camera->position();
+	glm::mat4 transform = data.camera.viewProjectionMatrix();
+	glm::mat4 camTransform = data.camera.viewRotationMatrix();
+	psc relative = data.position - data.camera.position();
 
 	transform = transform*camTransform;
 	transform = glm::mat4(1.0);
 	transform = glm::scale(transform, glm::vec3(0.01));
 
-	psc currentPosition = thisPosition;
-    psc campos = camera->position();
-    glm::mat4 camrot = camera->viewRotationMatrix();
-    PowerScaledScalar scaling = camera->scaling();
+	psc currentPosition = data.position;
+    psc campos = data.camera.position();
+    glm::mat4 camrot = data.camera.viewRotationMatrix();
+    PowerScaledScalar scaling = data.camera.scaling();
 
 	// Activate shader
 	_fieldlinesProgram->activate();
 
-    _fieldlinesProgram->setUniform("modelViewProjection", camera->viewProjectionMatrix());
+    _fieldlinesProgram->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
     _fieldlinesProgram->setUniform("modelTransform", transform);
     _fieldlinesProgram->setUniform("campos", campos.vec4());
     _fieldlinesProgram->setUniform("objpos", currentPosition.vec4());
@@ -253,7 +253,7 @@ void RenderableFieldlines::render(const Camera* camera, const psc& thisPosition,
 	_fieldlinesProgram->deactivate();
 }
 
-void RenderableFieldlines::update() {
+void RenderableFieldlines::update(const UpdateData& data) {
 }
 
 void RenderableFieldlines::safeShaderCompilation() {

src/rendering/renderablesphericalgrid.cpp

@@ -181,21 +181,21 @@ bool RenderableSphericalGrid::initialize(){
 	return completeSuccess;
 }
 
-void RenderableSphericalGrid::render(const Camera* camera, const psc& thisPosition, RuntimeData* runtimeData){
+void RenderableSphericalGrid::render(const RenderData& data){
 	assert(_gridProgram);
 	_gridProgram->activate();
 
 	// fetch data
-	psc currentPosition = thisPosition;
-	psc campos = camera->position();
-	glm::mat4 camrot = camera->viewRotationMatrix();
+	psc currentPosition = data.position;
+	psc campos = data.camera.position();
+	glm::mat4 camrot = data.camera.viewRotationMatrix();
 	// PowerScaledScalar scaling = camera->scaling();
 	PowerScaledScalar scaling = glm::vec2(1, -6);
 
 	glm::mat4 transform = glm::mat4(1);
 
 	// setup the data to the shader
-	_gridProgram->setUniform("ViewProjection", camera->viewProjectionMatrix());
+	_gridProgram->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
 	_gridProgram->setUniform("ModelTransform", transform);
 	_gridProgram->setUniform("campos", campos.vec4());
 	_gridProgram->setUniform("objpos", currentPosition.vec4());
@@ -216,7 +216,7 @@ void RenderableSphericalGrid::render(const Camera* camera, const psc& thisPositi
 	_gridProgram->deactivate();
 	
 }
-void RenderableSphericalGrid::update(){
-
+void RenderableSphericalGrid::update(const UpdateData& data){
 }
+
 }

src/rendering/renderablevolumegl.cpp

@@ -228,7 +228,7 @@ bool RenderableVolumeGL::deinitialize() {
     return true;
 }
 
-void RenderableVolumeGL::render(const Camera *camera, const psc &thisPosition, RuntimeData* runtimeData) {
+void RenderableVolumeGL::render(const RenderData& data) {
     if(_updateTransferfunction) {
         _updateTransferfunction = false;
         ghoul::opengl::Texture* transferFunction = loadTransferFunction(_transferFunctionPath);
@@ -248,10 +248,10 @@ void RenderableVolumeGL::render(const Camera *camera, const psc &thisPosition, R
     transform = glm::scale(transform, _boxScaling);
 
     // fetch data
-    psc currentPosition         = thisPosition;
-    psc campos                  = camera->position();
-    glm::mat4 camrot            = camera->viewRotationMatrix();
-    PowerScaledScalar scaling   = camera->scaling();
+    psc currentPosition         = data.position;
+    psc campos                  = data.camera.position();
+    glm::mat4 camrot            = data.camera.viewRotationMatrix();
+    PowerScaledScalar scaling   = data.camera.scaling();
 
     // psc addon(-1.1,0.0,0.0,0.0);
     // currentPosition += addon;
@@ -262,7 +262,7 @@ void RenderableVolumeGL::render(const Camera *camera, const psc &thisPosition, R
     _boxProgram->activate();
     _boxProgram->setUniform(_typeLocation, _id);
 
-    _boxProgram->setUniform("modelViewProjection", camera->viewProjectionMatrix());
+    _boxProgram->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
     _boxProgram->setUniform("modelTransform", transform);
     _boxProgram->setUniform("campos", campos.vec4());
     _boxProgram->setUniform("objpos", currentPosition.vec4());
@@ -284,7 +284,7 @@ void RenderableVolumeGL::render(const Camera *camera, const psc &thisPosition, R
     _boxProgram->deactivate();
 }
 
-void RenderableVolumeGL::update() {
+void RenderableVolumeGL::update(const UpdateData& data) {
 }
 
 } // namespace openspace

src/rendering/renderengine.cpp

@@ -51,7 +51,6 @@ namespace openspace {
 RenderEngine::RenderEngine()
     : _mainCamera(nullptr)
     , _sceneGraph(nullptr)
-	, _runtimeData(nullptr)
     , _abuffer(nullptr)
 {
 }
@@ -82,10 +81,6 @@ bool RenderEngine::initialize()
     return true;
 }
 
-void RenderEngine::setRuntimeData(RuntimeData* runtimeData){
-	_runtimeData = runtimeData;
-}
-
 bool RenderEngine::initializeGL()
 {
     // LDEBUG("RenderEngine::initializeGL()");
@@ -177,7 +172,7 @@ void RenderEngine::postSynchronizationPreDraw()
     _mainCamera->compileViewRotationMatrix();
 
     // update and evaluate the scene starting from the root node
-    _sceneGraph->update(); 
+	_sceneGraph->update({Time::ref().currentTime()}); 
     _mainCamera->setCameraDirection(glm::vec3(0, 0, -1));
     _sceneGraph->evaluate(_mainCamera);
 }
@@ -212,7 +207,7 @@ void RenderEngine::render()
     // render the scene starting from the root node
     _abuffer->clear();
     _abuffer->preRender();
-    _sceneGraph->render(_mainCamera);
+	_sceneGraph->render({*_mainCamera, psc()});
     _abuffer->postRender();
     _abuffer->resolve();
 
@@ -227,21 +222,15 @@ void RenderEngine::render()
 #endif
 
 
-		std::string timeGUI =  SpiceManager::ref().ephemerisTimeToString(_runtimeData->getTime());
-
-		if (timeGUI == "") _runtimeData->setTime(0); // if time ends -> reset time to julian date 0.
-
         const glm::vec2 scaling = _mainCamera->scaling();
         const glm::vec3 viewdirection = _mainCamera->viewDirection();
         const psc position = _mainCamera->position();
         const psc origin = OsEng.interactionHandler().getOrigin();
         const PowerScaledScalar pssl = (position - origin).length();
+
 		/* GUI PRINT */
 
-		Freetype::print(
-			  sgct_text::FontManager::instance()->getFont("SGCTFont", FONT_SIZE),
-			  FONT_SIZE, FONT_SIZE * 20, "OpenSpace Time: (%s)", timeGUI.c_str());
-		const std::string time = Time::ref().currentTimeUTC().c_str();
+		std::string&& time = Time::ref().currentTimeUTC().c_str();
 		Freetype::print(
 			  sgct_text::FontManager::instance()->getFont("SGCTFont", FONT_SIZE),
 			  FONT_SIZE, FONT_SIZE * 18, "Date: %s", time.c_str()

src/rendering/stars/renderablestars.cpp

@@ -306,17 +306,17 @@ bool RenderableStars::deinitialize(){
 }
 
 //#define TMAT
-void RenderableStars::render(const Camera* camera, const psc& thisPosition, RuntimeData* runtimeData){
+void RenderableStars::render(const RenderData& data){
 	assert(_haloProgram);
 	printOpenGLError();
 	// activate shader
 	_haloProgram->activate();
 
 	// fetch data
-	psc currentPosition       = thisPosition;
-	psc campos                = camera->position();
-	glm::mat4 camrot          = camera->viewRotationMatrix();
-	PowerScaledScalar scaling = camera->scaling();
+	psc currentPosition       = data.position;
+	psc campos                = data.camera.position();
+	glm::mat4 camrot          = data.camera.viewRotationMatrix();
+	PowerScaledScalar scaling = data.camera.scaling();
 	glm::mat4 transform       = glm::mat4(1); 
 	//scaling                   = glm::vec2(1, -22);  
 	scaling = glm::vec2(1, -19);  
@@ -332,9 +332,9 @@ void RenderableStars::render(const Camera* camera, const psc& thisPosition, Runt
 	glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE); 
 
 #ifdef GLSPRITES
-	glm::mat4 modelMatrix      = camera->modelMatrix();
-	glm::mat4 viewMatrix       = camera->viewMatrix();
-	glm::mat4 projectionMatrix = camera->projectionMatrix();
+	glm::mat4 modelMatrix      = data.camera.modelMatrix();
+	glm::mat4 viewMatrix       = data.camera.viewMatrix();
+	glm::mat4 projectionMatrix = data.camera.projectionMatrix();
 
 // ---------------------- RENDER HALOS -----------------------------
 	_haloProgram->setUniform("model", modelMatrix);
@@ -404,7 +404,7 @@ void RenderableStars::loadTexture(){
 	}
 }
 
-void RenderableStars::update()
+void RenderableStars::update(const UpdateData& data)
 {
 	
 }

src/scenegraph/ephemeris.cpp

@@ -68,6 +68,6 @@ bool Ephemeris::initialize() {
     return true;
 }
     
-void Ephemeris::update() {}
+void Ephemeris::update(const UpdateData& data) {}
 
 } // namespace openspace

src/scenegraph/scenegraph.cpp

@@ -32,6 +32,7 @@
 #include <openspace/util/constants.h>
 #include <openspace/util/shadercreator.h>
 #include <openspace/query/query.h>
+#include <openspace/util/time.h>
 
 // ghoul includes
 #include "ghoul/opengl/programobject.h"
@@ -196,7 +197,6 @@ SceneGraph::SceneGraph()
     : _focus(SceneGraphNode::RootNodeName)
     , _position(SceneGraphNode::RootNodeName)
     , _root(nullptr)
-	, _runtimeData(nullptr)
 {
 }
 
@@ -205,10 +205,6 @@ SceneGraph::~SceneGraph()
     deinitialize();
 }
 
-void SceneGraph::setRuntimeData(RuntimeData* runtimeData){
-	_runtimeData = runtimeData;
-}
-
 bool SceneGraph::initialize()
 {
     LDEBUG("Initializing SceneGraph");
@@ -457,7 +453,7 @@ bool SceneGraph::deinitialize()
     return true;
 }
 
-void SceneGraph::update()
+void SceneGraph::update(const UpdateData& data)
 {
 	if (!_sceneGraphToLoad.empty()) {
 		OsEng.renderEngine().sceneGraph()->clearSceneGraph();
@@ -468,7 +464,7 @@ void SceneGraph::update()
 	}
 
     for (auto node : _nodes)
-        node->update();
+        node->update(data);
 }
 
 void SceneGraph::evaluate(Camera* camera)
@@ -477,10 +473,10 @@ void SceneGraph::evaluate(Camera* camera)
 		_root->evaluate(camera);
 }
 
-void SceneGraph::render(Camera* camera)
+void SceneGraph::render(const RenderData& data)
 {
 	if (_root)
-		_root->render(camera);
+		_root->render(data);
 }
 
 void SceneGraph::scheduleLoadSceneFile(const std::string& sceneDescriptionFilePath) {
@@ -588,7 +584,7 @@ bool SceneGraph::loadSceneInternal(const std::string& sceneDescriptionFilePath)
 
     // Initialize all nodes
     for (auto node : _nodes) {
-		bool success = node->initialize(_runtimeData);
+		bool success = node->initialize();
         if (success)
             LDEBUG(node->name() << " initialized successfully!");
         else
@@ -596,8 +592,9 @@ bool SceneGraph::loadSceneInternal(const std::string& sceneDescriptionFilePath)
     }
 
     // update the position of all nodes
+	// TODO need to check this; unnecessary? (ab)
     for (auto node : _nodes)
-        node->update();
+		node->update({Time::ref().currentTime()});
 
     // Calculate the bounding sphere for the scenegraph
     _root->calculateBoundingSphere();

src/scenegraph/scenegraphnode.cpp

@@ -128,7 +128,6 @@ SceneGraphNode::SceneGraphNode()
     , _renderable(nullptr)
     , _renderableVisible(false)
     , _boundingSphereVisible(false)
-	, _runtimeData(nullptr)
 {
 }
 
@@ -137,7 +136,7 @@ SceneGraphNode::~SceneGraphNode()
     deinitialize();
 }
 
-bool SceneGraphNode::initialize(RuntimeData* runtimeData)
+bool SceneGraphNode::initialize()
 {
     if (_renderable != nullptr)
         _renderable->initialize();
@@ -145,7 +144,6 @@ bool SceneGraphNode::initialize(RuntimeData* runtimeData)
     if (_ephemeris != nullptr)
         _ephemeris->initialize();
 
-	_runtimeData = runtimeData;
     return true;
 }
 
@@ -173,9 +171,12 @@ bool SceneGraphNode::deinitialize()
 }
 
 // essential
-void SceneGraphNode::update()
+void SceneGraphNode::update(const UpdateData& data)
 {
-    _ephemeris->update(_runtimeData);
+	if (_ephemeris)
+		_ephemeris->update(data);
+	if (_renderable)
+		_renderable->update(data);
 }
 
 void SceneGraphNode::evaluate(const Camera* camera, const psc& parentPosition)
@@ -220,9 +221,11 @@ void SceneGraphNode::evaluate(const Camera* camera, const psc& parentPosition)
     }
 }
 
-void SceneGraphNode::render(const Camera* camera, const psc& parentPosition)
+void SceneGraphNode::render(const RenderData& data)
 {
-    const psc thisPosition = parentPosition + _ephemeris->position();
+    const psc thisPosition = data.position + _ephemeris->position();
+
+	RenderData newData = {data.camera, thisPosition};
 
     // check if camera is outside the node boundingsphere
     /*if (!_boundingSphereVisible) {
@@ -231,13 +234,13 @@ void SceneGraphNode::render(const Camera* camera, const psc& parentPosition)
 
     if (_renderableVisible && _renderable->isVisible()) {
         // LDEBUG("Render");
-		_renderable->render(camera, thisPosition, _runtimeData);
+		_renderable->render(newData);
     }
 
     // evaluate all the children, tail-recursive function(?)
 
     for (auto& child : _children) {
-        child->render(camera, thisPosition);
+        child->render(newData);
     }
 }
 
@@ -317,7 +320,6 @@ PowerScaledScalar SceneGraphNode::boundingSphere() const{
 // renderable
 void SceneGraphNode::setRenderable(Renderable* renderable) {
     _renderable = renderable;
-    update();
 }
 
 const Renderable* SceneGraphNode::renderable() const

src/scenegraph/spiceephemeris.cpp

@@ -78,15 +78,13 @@ const psc& SpiceEphemeris::position() const {
     return _position;
 }
 
-void SpiceEphemeris::update(RuntimeData* runtimeData) {
+void SpiceEphemeris::update(const UpdateData& data) {
     double state[3];
    
-	_currentEphemerisTime = runtimeData->getTime();
-	
 	glm::dvec3 position(0,0,0);
 
 	double lightTime = 0.0;
-	SpiceManager::ref().getTargetPosition(_targetName, _currentEphemerisTime, "GALACTIC", "LT+S", _originName, position, lightTime);
+	SpiceManager::ref().getTargetPosition(_targetName, data.time, "GALACTIC", "LT+S", _originName, position, lightTime);
 
 	/*
 	std::cout << _targetName  << " (";

src/scenegraph/staticephemeris.cpp

@@ -47,7 +47,7 @@ const psc& StaticEphemeris::position() const {
     return _position;
 }
 
-void StaticEphemeris::update(RuntimeData* runtimeData) {
+void StaticEphemeris::update(const UpdateData&) {
 
 }