Some work towards multi-pipe

include/openspace/engine/openspaceengine.h

@@ -83,6 +83,8 @@ private:
     RenderEngine* _renderEngine;
     // ScriptEngine* _scriptEngine;
     ghoul::opencl::CLContext _context;
+
+    sgct::SharedVector<char> _synchronizationBuffer;
 };
 
 #define OsEng (openspace::OpenSpaceEngine::ref())

include/openspace/rendering/renderengine.h

@@ -44,15 +44,16 @@ public:
     void setSceneGraph(std::shared_ptr<SceneGraph> sceneGraph);
     std::shared_ptr<SceneGraph> sceneGraph();
 
+    Camera* camera() const;
+
 	// sgct wrapped functions
     bool initializeGL();
     void postSynchronizationPreDraw();
     void render();
     void postDraw();
 
-	// object extensions
-	//virtual void encode();
-	//virtual void decode();
+	void serialize(std::vector<char>& dataStream, size_t& offset);
+	void deserialize(const std::vector<char>& dataStream, size_t& offset);
 	
 private:
 	Camera* _mainCamera;

include/openspace/util/camera.h

@@ -58,6 +58,7 @@ public:
     const glm::quat& rotation() const;
 
     const glm::vec3& viewDirection() const;
+    
     const float& maxFov() const;
     const float& sinMaxFov() const;
     void setMaxFov(float fov);

include/openspace/util/psc.h

@@ -36,9 +36,9 @@ public:
 	const double * value_ptr();
 	const float * value_ptrf();
 	glm::dvec4 getVec4() const;
-	glm::vec4 getVec4f();
+	glm::vec4 getVec4f() const;
 	glm::dvec3 getVec3() const;
-	glm::vec3 getVec3f();
+	glm::vec3 getVec3f() const;
 	pss length() const;
 	glm::dvec3 getDirection() const;
 	glm::vec3 getDirectionf() const;
@@ -88,7 +88,7 @@ private:
 	glm::dvec4 vec_;
 
 	// float vector used when returning float values
-	glm::vec4 vecf_;
+	mutable glm::vec4 vecf_;
 
 };
 

src/engine/openspaceengine.cpp

@@ -201,6 +201,9 @@ void OpenSpaceEngine::create(int argc, char** argv,
     sgctArguments.push_back(argv[0]);
     sgctArguments.push_back("-config");
     sgctArguments.push_back(absPath(sgctConfigurationPath));
+
+    for (int i = 1; i < argc; ++i)
+        sgctArguments.push_back(argv[i]);
 }
 
 void OpenSpaceEngine::destroy()
@@ -369,10 +372,24 @@ void OpenSpaceEngine::mouseScrollWheelCallback(int pos)
 
 void OpenSpaceEngine::encode()
 {
+    std::vector<char> dataStream(1024);
+
+    size_t offset = 0;
+    // serialization
+    _renderEngine->serialize(dataStream, offset);
+
+    _synchronizationBuffer.setVal(dataStream);
+    sgct::SharedData::instance()->writeVector(&_synchronizationBuffer);
 }
 
 void OpenSpaceEngine::decode()
 {
+    sgct::SharedData::instance()->readVector(&_synchronizationBuffer);
+    std::vector<char> dataStream = std::move(_synchronizationBuffer.getVal());
+    size_t offset = 0;
+
+    // deserialize in the same order as done in serialization
+    _renderEngine->deserialize(dataStream, offset);
 }
 
 }  // namespace openspace

src/rendering/renderengine.cpp

@@ -28,10 +28,12 @@
 #include <openspace/scenegraph/scenegraph.h>
 #include <openspace/util/camera.h>
 
-//#include "sgct.h"
+#include "sgct.h"
 
 #include <ghoul/filesystem/filesystem.h>
 
+#include <array>
+
 namespace {
 const std::string _loggerCat = "RenderEngine";
 }
@@ -56,7 +58,7 @@ bool RenderEngine::initialize()
     _mainCamera->setPosition(psc(0.0, 0.0, 1.499823, 11.0));
 
     // if master, setup interaction
-    if (sgct::Engine::instance()->isMaster())
+    //if (sgct::Engine::instance()->isMaster())
         OsEng.interactionHandler().setCamera(_mainCamera);
 
     return true;
@@ -212,4 +214,178 @@ void RenderEngine::setSceneGraph(std::shared_ptr<SceneGraph> sceneGraph)
     _sceneGraph = sceneGraph;
 }
 
+void RenderEngine::serialize(std::vector<char>& dataStream, size_t& offset) {
+    // TODO: This has to be redone properly (ab) [new class providing methods to serialize
+    // variables]
+
+    // _viewRotation
+    // _cameraDirection
+    // camera->position
+    // camera->viewRotationMatrix
+    // camera->scaling
+
+
+    const glm::vec2 scaling = _mainCamera->scaling();
+    const psc position = _mainCamera->position();
+    //const psc origin = OsEng.interactionHandler().getOrigin();
+    //const pss pssl = (position - origin).length();
+    //_mainCamera->cameraDirection()
+
+    union storage {
+        float value;
+        std::array<char, 4> representation;
+    } s;
+
+    s.value = _mainCamera->cameraDirection().x;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->cameraDirection().y;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->cameraDirection().z;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->rotation().x;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->rotation().y;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->rotation().z;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->rotation().w;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->position().getVec4f().x;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->position().getVec4f().y;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->position().getVec4f().z;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+
+    s.value = _mainCamera->position().getVec4f().w;
+    dataStream[offset++] = s.representation[0];
+    dataStream[offset++] = s.representation[1];
+    dataStream[offset++] = s.representation[2];
+    dataStream[offset++] = s.representation[3];
+}
+
+void RenderEngine::deserialize(const std::vector<char>& dataStream, size_t& offset) {
+    // TODO: This has to be redone properly (ab)
+
+    union storage {
+        float value;
+        std::array<char, 4> representation;
+    } s;
+
+    glm::vec3 cameraDirection;
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    cameraDirection.x = s.value;
+
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    cameraDirection.y = s.value;
+
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    cameraDirection.z = s.value;
+    _mainCamera->setCameraDirection(cameraDirection);
+
+    glm::quat rotation;
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    rotation.x = s.value;
+
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    rotation.y = s.value;
+
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    rotation.z = s.value;
+
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    rotation.w = s.value;
+    _mainCamera->setRotation(rotation);
+
+    glm::vec4 position;
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    position.x = s.value;
+
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    position.y = s.value;
+
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    position.z = s.value;
+
+    s.representation[0] = dataStream[offset++];
+    s.representation[1] = dataStream[offset++];
+    s.representation[2] = dataStream[offset++];
+    s.representation[3] = dataStream[offset++];
+    position.w = s.value;
+    _mainCamera->setPosition(position);
+}
+
+Camera* RenderEngine::camera() const {
+    return _mainCamera;
+}
+
 }  // namespace openspace

src/scenegraph/scenegraph.cpp

@@ -170,7 +170,8 @@ bool SceneGraph::initialize()
                                       << "'");
         SceneGraphNode* focusNode = focusIterator->second;
         SceneGraphNode* positionNode = positionIterator->second;
-        Camera* c = OsEng.interactionHandler().getCamera();
+        Camera* c = OsEng.ref().renderEngine().camera();
+        //Camera* c = OsEng.interactionHandler().getCamera();
 
         // TODO: Make distance depend on radius
         // TODO: Set distance and camera direction in some more smart way

src/util/camera.cpp

@@ -35,6 +35,7 @@ namespace openspace {
 Camera::Camera()
     : _scaling(1.f, 0.f)
     , _viewRotation(glm::quat(glm::vec3(0.f, 0.f, 0.f)))
+    , _cameraDirection(0.f, 0.f, 0.f)
 {
 }
 

src/util/psc.cpp

@@ -81,7 +81,7 @@ glm::dvec4  psc::getVec4() const{
 	return vec_;
 }
 
-glm::vec4  psc::getVec4f() {
+glm::vec4  psc::getVec4f() const {
 	vecf_ = glm::vec4(vec_);
 	return vecf_;
 }
@@ -90,7 +90,7 @@ glm::dvec3 psc::getVec3() const {
 	return glm::dvec3(vec_[0]*pow(k,vec_[3]),vec_[1]*pow(k,vec_[3]),vec_[2]*pow(k,vec_[3]));
 }
 
-glm::vec3 psc::getVec3f() {
+glm::vec3 psc::getVec3f() const {
 	return glm::vec3(vec_[0]*pow(k,vec_[3]),vec_[1]*pow(k,vec_[3]),vec_[2]*pow(k,vec_[3]));
 }