SPICE-time dependency, retrieval of spice ephemerides and rotational matrix + coordinate references.

Added functionality:
- New class renderablesphericalgrid is repurposed code from powerscaledsphere class.
  Due to z-buffer issues used as reference grid to confirm planetary orbits are correct.
  This has been a major problem as prior we had no visual reference.
  Now we have a Galactic-, Celestial- and Ecliptic-coordinate grid.
  To this also added separate shader: grid_vs.glsl / grid_fs.glsl
  These grids have a static-rotational matrix derived from partiview (thanks to Brian)
  since spice req. to-from frame to compute rotational matrix.

Time dependency:
- Added struct RuntimeData - which for now only contains openspace time and is passed to all renderables
- All renderables accept runtimeData, keep private reference and use for computation of rotational matrix
- This obviously carries corresponding changes to Scenegraph and ScenegraphNode.

Spicemanager:
- Added function that more easily provides access to rotational matrix used in spice
 (used in renderableplanet for computing planetary objects spin around axis)

Ephemeris-classes:
- Now compute ephemeris from spice based on timeepoch in runtimedata
  TODO: once z-buffer fixed - set ephemeris correctly as meters (not kilometers)

Renderengine:
- Advances time with the advanceTime method in RuntimeData struct

ISSUES:
- Our Y axis NOT same as SPICE or star-catalogue, all renderables rotated now 90deg, needs redefinition,
  lots of debugging and major headaches before this conclusion.
- Depth buffer needs to be fixed in order to properly place planets.
- Spice kernels have finite time-range, when time stops - simulation ends - ugly fix: reset time to zero.
  Possible fix: kernels de431 (part 1-2) cover huge timespan and most likely have functions to extrapolate time,
  drawback is that they are 1,7 gb each.

TODO:
- Compute and draw dynamic ephemeries for each renderable. Either do full year sweep then update for each point or
  create a tail of linesegments for each planet. Dont know yet how to do this, would like spicephemeris to be
  sub-class of Renderable (have own render() method) - good/bad?

src/rendering/planets/renderableplanet.cpp

@@ -31,6 +31,9 @@
 #include <ghoul/opengl/textureunit.h>
 #include <ghoul/filesystem/filesystem.h>
 
+#include <openspace/util/time.h>
+#include <openspace/util/spicemanager.h>
+
 #include <openspace/engine/openspaceengine.h>
 #include <sgct.h>
 
@@ -56,10 +59,11 @@ RenderablePlanet::RenderablePlanet(const ghoul::Dictionary& dictionary)
         geometryDictionary.setValue(constants::scenegraph::keyPathModule, path);
         geometryDictionary.setValue(constants::scenegraphnode::keyName, name());
 
-        _geometry
-              = planetgeometry::PlanetGeometry::createFromDictionary(geometryDictionary);
+        _geometry = planetgeometry::PlanetGeometry::createFromDictionary(geometryDictionary);
     }
 
+	dictionary.getValue("Frame", _target);
+
     // TODO: textures need to be replaced by a good system similar to the geometry as soon
     // as the requirements are fixed (ab)
     std::string texturePath = "";
@@ -105,7 +109,7 @@ bool RenderablePlanet::deinitialize()
     return true;
 }
 
-void RenderablePlanet::render(const Camera* camera, const psc& thisPosition)
+void RenderablePlanet::render(const Camera* camera, const psc& thisPosition, RuntimeData* runtimeData)
 {
     // TODO replace with more robust assert
     // check so that the shader is set
@@ -117,19 +121,30 @@ void RenderablePlanet::render(const Camera* camera, const psc& thisPosition)
 
     // fetch data
     psc currentPosition = thisPosition;
-    psc campos = camera->position();
-    glm::mat4 camrot = camera->viewRotationMatrix();
-    //PowerScaledScalar scaling = camera->scaling();
-	//std::cout << scaling << std::endl;
+	psc campos          = camera->position();
+    glm::mat4 camrot    = camera->viewRotationMatrix();
+   // PowerScaledScalar scaling = camera->scaling();
 
-	PowerScaledScalar scaling = glm::vec2(1, -6);
+    PowerScaledScalar scaling = glm::vec2(1, -6);
 
     // scale the planet to appropriate size since the planet is a unit sphere
     glm::mat4 transform = glm::mat4(1);
-    transform = glm::rotate(
-          transform, 4.1f * static_cast<float>(sgct::Engine::instance()->getTime()),
-          glm::vec3(0.0f, 1.0f, 0.0f));
-		  
+	
+	// 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 = transform* rot;
+	
+
     // setup the data to the shader
     _programObject->setUniform("ViewProjection", camera->viewProjectionMatrix());
     _programObject->setUniform("ModelTransform", transform);
@@ -137,7 +152,7 @@ void RenderablePlanet::render(const Camera* camera, const psc& thisPosition)
     _programObject->setUniform("objpos", currentPosition.vec4());
     _programObject->setUniform("camrot", camrot);
     _programObject->setUniform("scaling", scaling.vec2());
-
+	
     // Bind texture
     ghoul::opengl::TextureUnit unit;
     unit.activate();
@@ -149,6 +164,7 @@ void RenderablePlanet::render(const Camera* camera, const psc& thisPosition)
 
     // disable shader
     _programObject->deactivate();
+
 }
 
 void RenderablePlanet::update()