Separate Renderable::initialize into initialize and initializeGL functions

Handle initialize in a separate thread and display rudimentary loading screen

include/openspace/engine/wrapper/sgctwindowwrapper.h

@@ -79,6 +79,8 @@ public:
 
     void takeScreenshot(bool applyWarping = false) const override;
 
+    void swapBuffer() const override;
+
 private:
     properties::FloatProperty _eyeSeparation;
     properties::BoolProperty _showStatsGraph;

include/openspace/engine/wrapper/windowwrapper.h

@@ -270,6 +270,8 @@ public:
      */
     virtual void takeScreenshot(bool applyWarping = false) const;
 
+    virtual void swapBuffer() const;
+
     struct WindowWrapperException : public ghoul::RuntimeError {
         explicit WindowWrapperException(const std::string& msg);
     };

include/openspace/rendering/renderable.h

@@ -65,7 +65,9 @@ public:
     virtual ~Renderable();
 
     virtual void initialize();
+    virtual void initializeGL();
     virtual void deinitialize();
+    virtual void deinitializeGL();
 
     virtual bool isReady() const = 0;
     bool isEnabled() const;

include/openspace/rendering/screenspacerenderable.h

@@ -60,7 +60,10 @@ public:
     virtual void render();
     
     virtual bool initialize();
+    virtual bool initializeGL();
     virtual bool deinitialize();
+    virtual bool deinitializeGL();
+
     virtual void update() = 0;
     virtual bool isReady() const;
     bool isEnabled() const;

include/openspace/scene/scene.h

@@ -72,6 +72,12 @@ public:
      * Initalizes the SceneGraph
      */
     void initialize();
+    
+    /**
+     * Initializes the OpenGL part of the SceneGraph
+     */
+    void initializeGL();
+
 
     /**
      * Clear the scene graph,

include/openspace/scene/scenegraphnode.h

@@ -76,7 +76,9 @@ public:
     static std::unique_ptr<SceneGraphNode> createFromDictionary(const ghoul::Dictionary& dictionary);
 
     void initialize();
+    void initializeGL();
     void deinitialize();
+    void deinitializeGL();
 
     void traversePreOrder(std::function<void(SceneGraphNode*)> fn);
     void traversePostOrder(std::function<void(SceneGraphNode*)> fn);

modules/base/rendering/renderablemodel.cpp

@@ -156,7 +156,7 @@ bool RenderableModel::isReady() const {
     return _programObject && _texture;
 }
 
-void RenderableModel::initialize() {
+void RenderableModel::initializeGL() {
     _programObject = OsEng.renderEngine().buildRenderProgram(
         "ModelProgram",
         "${MODULE_BASE}/shaders/model_vs.glsl",
@@ -168,7 +168,7 @@ void RenderableModel::initialize() {
     _geometry->initialize(this); 
 }
 
-void RenderableModel::deinitialize() {
+void RenderableModel::deinitializeGL() {
     if (_geometry) {
         _geometry->deinitialize();
         _geometry = nullptr;

modules/base/rendering/renderablemodel.h

@@ -51,8 +51,8 @@ class RenderableModel : public Renderable {
 public:
     RenderableModel(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/base/rendering/renderableplane.cpp

@@ -179,7 +179,7 @@ bool RenderablePlane::isReady() const {
     return _shader && _texture;
 }
 
-void RenderablePlane::initialize() {
+void RenderablePlane::initializeGL() {
     glGenVertexArrays(1, &_quad); // generate array
     glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
     createPlane();
@@ -192,7 +192,7 @@ void RenderablePlane::initialize() {
     loadTexture();
 }
 
-void RenderablePlane::deinitialize() {
+void RenderablePlane::deinitializeGL() {
     glDeleteVertexArrays(1, &_quad);
     _quad = 0;
 

modules/base/rendering/renderableplane.h

@@ -54,8 +54,8 @@ class RenderablePlane : public Renderable {
 public:
     RenderablePlane(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/base/rendering/renderablesphere.cpp

@@ -218,7 +218,7 @@ bool RenderableSphere::isReady() const {
     return _shader && _texture;
 }
 
-void RenderableSphere::initialize() {
+void RenderableSphere::initializeGL() {
     _sphere = std::make_unique<PowerScaledSphere>(
         PowerScaledScalar::CreatePSS(_size), _segments
     );
@@ -232,7 +232,7 @@ void RenderableSphere::initialize() {
     loadTexture();
 }
 
-void RenderableSphere::deinitialize() {
+void RenderableSphere::deinitializeGL() {
     _texture = nullptr;
 
     if (_shader) {

modules/base/rendering/renderablesphere.h

@@ -49,8 +49,8 @@ class RenderableSphere : public Renderable {
 public:
     RenderableSphere(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/base/rendering/renderablesphericalgrid.cpp

@@ -177,18 +177,7 @@ bool RenderableSphericalGrid::isReady() const {
     return ready;
 }
 
-void RenderableSphericalGrid::deinitialize() {
-    glDeleteVertexArrays(1,&_vaoID);
-    _vaoID = 0;
-
-    glDeleteBuffers(1,&_vBufferID);
-    _vBufferID = 0;
-
-    glDeleteBuffers(1,&_iBufferID);
-    _iBufferID = 0;
-}
-
-void RenderableSphericalGrid::initialize() {
+void RenderableSphericalGrid::initializeGL() {
     _gridProgram = OsEng.renderEngine().buildRenderProgram(
             "GridProgram",
             "${MODULE_BASE}/shaders/grid_vs.glsl",
@@ -206,6 +195,17 @@ void RenderableSphericalGrid::initialize() {
     glBindVertexArray(0);
 }
 
+void RenderableSphericalGrid::deinitializeGL() {
+    glDeleteVertexArrays(1, &_vaoID);
+    _vaoID = 0;
+
+    glDeleteBuffers(1, &_vBufferID);
+    _vBufferID = 0;
+
+    glDeleteBuffers(1, &_iBufferID);
+    _iBufferID = 0;
+}
+
 void RenderableSphericalGrid::render(const RenderData& data, RendererTasks&){
     _gridProgram->activate();
 

modules/base/rendering/renderablesphericalgrid.h

@@ -48,8 +48,8 @@ public:
     RenderableSphericalGrid(const ghoul::Dictionary& dictionary);
     ~RenderableSphericalGrid();
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/base/rendering/renderabletrail.cpp

@@ -217,7 +217,7 @@ RenderableTrail::RenderableTrail(const ghoul::Dictionary& dictionary)
     addProperty(_renderingModes);
 }
 
-void RenderableTrail::initialize() {
+void RenderableTrail::initializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     _programObject = renderEngine.buildRenderProgram(
         "EphemerisProgram",
@@ -228,7 +228,7 @@ void RenderableTrail::initialize() {
     setRenderBin(Renderable::RenderBin::Overlay);
 }
 
-void RenderableTrail::deinitialize() {
+void RenderableTrail::deinitializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     if (_programObject) {
         renderEngine.removeRenderProgram(_programObject);

modules/base/rendering/renderabletrail.h

@@ -73,8 +73,8 @@ class RenderableTrail : public Renderable {
 public:
     ~RenderableTrail() = default;
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/base/rendering/renderabletrailorbit.cpp

@@ -169,20 +169,20 @@ RenderableTrailOrbit::RenderableTrailOrbit(const ghoul::Dictionary& dictionary)
     _primaryRenderInformation.sorting = RenderInformation::VertexSorting::NewestFirst;
 }
 
-void RenderableTrailOrbit::initialize() {
-    RenderableTrail::initialize();
+void RenderableTrailOrbit::initializeGL() {
+    RenderableTrail::initializeGL();
 
     glGenVertexArrays(1, &_primaryRenderInformation._vaoID);
     glGenBuffers(1, &_primaryRenderInformation._vBufferID);
     glGenBuffers(1, &_primaryRenderInformation._iBufferID);
 }
 
-void RenderableTrailOrbit::deinitialize() {
+void RenderableTrailOrbit::deinitializeGL() {
     glDeleteVertexArrays(1, &_primaryRenderInformation._vaoID);
     glDeleteBuffers(1, &_primaryRenderInformation._vBufferID);
     glDeleteBuffers(1, &_primaryRenderInformation._iBufferID);
 
-    RenderableTrail::deinitialize();
+    RenderableTrail::deinitializeGL();
 }
 
 void RenderableTrailOrbit::update(const UpdateData& data) {

modules/base/rendering/renderabletrailorbit.h

@@ -48,8 +48,8 @@ class RenderableTrailOrbit : public RenderableTrail {
 public:
     explicit RenderableTrailOrbit(const ghoul::Dictionary& dictionary);
     
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     void update(const UpdateData& data) override;
     

modules/base/rendering/renderabletrailtrajectory.cpp

@@ -187,8 +187,8 @@ RenderableTrailTrajectory::RenderableTrailTrajectory(const ghoul::Dictionary& di
     _primaryRenderInformation.sorting = RenderInformation::VertexSorting::OldestFirst;
 }
 
-void RenderableTrailTrajectory::initialize() {
-    RenderableTrail::initialize();
+void RenderableTrailTrajectory::initializeGL() {
+    RenderableTrail::initializeGL();
 
     // We don't need an index buffer, so we keep it at the default value of 0
     glGenVertexArrays(1, &_primaryRenderInformation._vaoID);
@@ -201,14 +201,14 @@ void RenderableTrailTrajectory::initialize() {
     _floatingRenderInformation.sorting = RenderInformation::VertexSorting::OldestFirst;
 }
 
-void RenderableTrailTrajectory::deinitialize() {
+void RenderableTrailTrajectory::deinitializeGL() {
     glDeleteVertexArrays(1, &_primaryRenderInformation._vaoID);
     glDeleteBuffers(1, &_primaryRenderInformation._vBufferID);
 
     glDeleteVertexArrays(1, &_floatingRenderInformation._vaoID);
     glDeleteBuffers(1, &_floatingRenderInformation._vBufferID);
 
-    RenderableTrail::deinitialize();
+    RenderableTrail::deinitializeGL();
 }
 
 void RenderableTrailTrajectory::update(const UpdateData& data) {

modules/base/rendering/renderabletrailtrajectory.h

@@ -53,8 +53,8 @@ class RenderableTrailTrajectory : public RenderableTrail {
 public:
     explicit RenderableTrailTrajectory(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     void update(const UpdateData& data) override;
    

modules/base/rendering/screenspaceframebuffer.cpp

@@ -75,15 +75,15 @@ ScreenSpaceFramebuffer::ScreenSpaceFramebuffer(const ghoul::Dictionary& dictiona
 
 ScreenSpaceFramebuffer::~ScreenSpaceFramebuffer() {}
 
-bool ScreenSpaceFramebuffer::initialize() {
-    ScreenSpaceRenderable::initialize();
+bool ScreenSpaceFramebuffer::initializeGL() {
+    ScreenSpaceRenderable::initializeGL();
     createFragmentbuffer();
 
     return isReady();
 }
 
-bool ScreenSpaceFramebuffer::deinitialize() {
-    ScreenSpaceRenderable::deinitialize();
+bool ScreenSpaceFramebuffer::deinitializeGL() {
+    ScreenSpaceRenderable::deinitializeGL();
 
     _framebuffer->detachAll();
     removeAllRenderFunctions();

modules/base/rendering/screenspaceframebuffer.h

@@ -45,8 +45,8 @@ public:
     ScreenSpaceFramebuffer(const ghoul::Dictionary& dictionary = ghoul::Dictionary());
     ~ScreenSpaceFramebuffer();
 
-    bool initialize() override;
-    bool deinitialize() override;
+    bool initializeGL() override;
+    bool deinitializeGL() override;
     void render() override;
     void update() override;
     bool isReady() const override;

modules/debugging/rendering/renderabledebugplane.cpp

@@ -190,7 +190,7 @@ bool RenderableDebugPlane::isReady() const {
     return ready;
 }
 
-void RenderableDebugPlane::initialize() {
+void RenderableDebugPlane::initializeGL() {
     glGenVertexArrays(1, &_quad); // generate array
     glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
     createPlane();
@@ -204,7 +204,7 @@ void RenderableDebugPlane::initialize() {
     }
 }
 
-void RenderableDebugPlane::deinitialize() {
+void RenderableDebugPlane::deinitializeGL() {
     glDeleteVertexArrays(1, &_quad);
     _quad = 0;
 

modules/debugging/rendering/renderabledebugplane.h

@@ -49,8 +49,8 @@ public:
     RenderableDebugPlane(const ghoul::Dictionary& dictionary);
     ~RenderableDebugPlane();
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/digitaluniverse/rendering/renderablebillboardscloud.cpp

@@ -475,13 +475,6 @@ bool RenderableBillboardsCloud::isReady() const {
 }
 
 void RenderableBillboardsCloud::initialize() {
-    RenderEngine& renderEngine = OsEng.renderEngine();
-        
-    _program = renderEngine.buildRenderProgram("RenderableBillboardsCloud",
-        "${MODULE_DIGITALUNIVERSE}/shaders/billboard2_vs.glsl",
-        "${MODULE_DIGITALUNIVERSE}/shaders/billboard2_fs.glsl",
-        "${MODULE_DIGITALUNIVERSE}/shaders/billboard2_gs.glsl");
-                
     bool success = loadData();
     if (!success) {
         throw ghoul::RuntimeError("Error loading data");
@@ -490,8 +483,17 @@ void RenderableBillboardsCloud::initialize() {
     if (!_colorOptionString.empty()) {
         // Following DU behavior here. The last colormap variable 
         // entry is the one selected by default.
-        _colorOption.setValue(_colorRangeData.size()-1);
-    }        
+        _colorOption.setValue(_colorRangeData.size() - 1);
+    }
+}
+
+void RenderableBillboardsCloud::initializeGL() {
+    RenderEngine& renderEngine = OsEng.renderEngine();
+        
+    _program = renderEngine.buildRenderProgram("RenderableBillboardsCloud",
+        "${MODULE_DIGITALUNIVERSE}/shaders/billboard2_vs.glsl",
+        "${MODULE_DIGITALUNIVERSE}/shaders/billboard2_fs.glsl",
+        "${MODULE_DIGITALUNIVERSE}/shaders/billboard2_gs.glsl");
 
     if (_hasPolygon) {
         createPolygonTexture();
@@ -509,7 +511,7 @@ void RenderableBillboardsCloud::initialize() {
     }
 }
 
-void RenderableBillboardsCloud::deinitialize() {
+void RenderableBillboardsCloud::deinitializeGL() {
     glDeleteBuffers(1, &_vbo);
     _vbo = 0;
     glDeleteVertexArrays(1, &_vao);

modules/digitaluniverse/rendering/renderablebillboardscloud.h

@@ -59,7 +59,8 @@ public:
     ~RenderableBillboardsCloud() = default;
 
     void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/digitaluniverse/rendering/renderabledumeshes.cpp

@@ -371,7 +371,7 @@ bool RenderableDUMeshes::isReady() const {
     return (_program != nullptr) && (!_renderingMeshesMap.empty() || (!_labelData.empty()));
 }
 
-void RenderableDUMeshes::initialize() {
+void RenderableDUMeshes::initializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     _program = renderEngine.buildRenderProgram("RenderableDUMeshes",
         "${MODULE_DIGITALUNIVERSE}/shaders/dumesh_vs.glsl",
@@ -396,7 +396,7 @@ void RenderableDUMeshes::initialize() {
     }
 }
 
-void RenderableDUMeshes::deinitialize() {
+void RenderableDUMeshes::deinitializeGL() {
     for (const std::pair<int, RenderingMesh>& pair : _renderingMeshesMap) {
         for (int i = 0; i < pair.second.numU; ++i) {
             glDeleteVertexArrays(1, &pair.second.vaoArray[i]);

modules/digitaluniverse/rendering/renderabledumeshes.h

@@ -56,8 +56,8 @@ public:
     explicit RenderableDUMeshes(const ghoul::Dictionary& dictionary);
     ~RenderableDUMeshes() = default;
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/digitaluniverse/rendering/renderableplanescloud.cpp

@@ -420,17 +420,19 @@ bool RenderablePlanesCloud::isReady() const {
 }
 
 void RenderablePlanesCloud::initialize() {
+    bool success = loadData();
+    if (!success) {
+        throw ghoul::RuntimeError("Error loading data");
+    }
+}
+
+void RenderablePlanesCloud::initializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     
     _program = renderEngine.buildRenderProgram("RenderablePlanesCloud",
         "${MODULE_DIGITALUNIVERSE}/shaders/plane2_vs.glsl",
         "${MODULE_DIGITALUNIVERSE}/shaders/plane2_fs.glsl");
             
-    bool success = loadData();
-    if (!success) {
-        throw ghoul::RuntimeError("Error loading data");
-    }
-
     createPlanes();
 
     loadTextures();
@@ -455,7 +457,7 @@ void RenderablePlanesCloud::deleteDataGPU() {
     }
 }
 
-void RenderablePlanesCloud::deinitialize() {
+void RenderablePlanesCloud::deinitializeGL() {
     deleteDataGPU();
    
     RenderEngine& renderEngine = OsEng.renderEngine();

modules/digitaluniverse/rendering/renderableplanescloud.h

@@ -61,7 +61,8 @@ namespace openspace {
         ~RenderablePlanesCloud() = default;
 
         void initialize() override;
-        void deinitialize() override;
+        void initializeGL() override;
+        void deinitializeGL() override;
 
         bool isReady() const override;
 

modules/digitaluniverse/rendering/renderablepoints.cpp

@@ -254,6 +254,13 @@ namespace openspace {
     }
 
     void RenderablePoints::initialize() {
+        bool success = loadData();
+        if (!success) {
+            throw ghoul::RuntimeError("Error loading data");
+        }
+    }
+
+    void RenderablePoints::initializeGL() {
         RenderEngine& renderEngine = OsEng.renderEngine();
         if (_hasSpriteTexture) {
             _program = renderEngine.buildRenderProgram("RenderablePoints",
@@ -266,14 +273,9 @@ namespace openspace {
                 "${MODULE_DIGITALUNIVERSE}/shaders/points_fs.glsl");// ,
                 //"${MODULE_DIGITALUNIVERSE}/shaders/points_gs.glsl");
         }
-        
-        bool success = loadData();
-        if (!success) {
-            throw ghoul::RuntimeError("Error loading data");
-        }
     }
 
-    void RenderablePoints::deinitialize() {
+    void RenderablePoints::deinitializeGL() {
         glDeleteBuffers(1, &_vbo);
         _vbo = 0;
         glDeleteVertexArrays(1, &_vao);

modules/digitaluniverse/rendering/renderablepoints.h

@@ -54,7 +54,8 @@ namespace openspace {
         ~RenderablePoints() = default;
 
         void initialize() override;
-        void deinitialize() override;
+        void initializeGL() override;
+        void deinitializeGL() override;
 
         bool isReady() const override;
 

modules/fieldlines/rendering/renderablefieldlines.cpp

@@ -232,7 +232,7 @@ bool RenderableFieldlines::isReady() const {
     return programReady && vectorFieldReady && fieldlineReady && seedPointsReady;
 }
 
-void RenderableFieldlines::initialize() {
+void RenderableFieldlines::initializeGL() {
     if (_vectorFieldInfo.empty() || _fieldlineInfo.empty() || _seedPointsInfo.empty()) {
         throw ghoul::RuntimeError("Error initializing");
     }
@@ -245,7 +245,7 @@ void RenderableFieldlines::initialize() {
     );
 }
 
-void RenderableFieldlines::deinitialize() {
+void RenderableFieldlines::deinitializeGL() {
     glDeleteVertexArrays(1, &_fieldlineVAO);
     _fieldlineVAO = 0;
     glDeleteBuffers(1, &_vertexPositionBuffer);

modules/fieldlines/rendering/renderablefieldlines.h

@@ -45,8 +45,8 @@ class RenderableFieldlines : public Renderable {
 public:
     RenderableFieldlines(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/galaxy/rendering/renderablegalaxy.cpp

@@ -153,7 +153,7 @@ namespace openspace {
     
 RenderableGalaxy::~RenderableGalaxy() {}
 
-void RenderableGalaxy::initialize() {
+void RenderableGalaxy::initializeGL() {
     // Aspect is currently hardcoded to cubic voxels.
     _aspect = static_cast<glm::vec3>(_volumeDimensions);
     _aspect = _aspect / std::max(std::max(_aspect.x, _aspect.y), _aspect.z);
@@ -275,7 +275,7 @@ void RenderableGalaxy::initialize() {
     glBindVertexArray(0);
 }
     
-void RenderableGalaxy::deinitialize() {
+void RenderableGalaxy::deinitializeGL() {
     if (_raycaster) {
         OsEng.renderEngine().raycasterManager().detachRaycaster(*_raycaster.get());
         _raycaster = nullptr;

modules/galaxy/rendering/renderablegalaxy.h

@@ -41,8 +41,8 @@ public:
     RenderableGalaxy(const ghoul::Dictionary& dictionary);
     ~RenderableGalaxy();
     
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
     bool isReady() const override;
     void render(const RenderData& data, RendererTasks& tasks) override;
     void update(const UpdateData& data) override;

modules/globebrowsing/globes/renderableglobe.cpp

@@ -264,12 +264,12 @@ RenderableGlobe::RenderableGlobe(const ghoul::Dictionary& dictionary)
     _chunkedLodGlobe->recompileShaders();
 }
 
-void RenderableGlobe::initialize() {
-    _distanceSwitch.initialize();
+void RenderableGlobe::initializeGL() {
+    _distanceSwitch.initializeGL();
 }
 
-void RenderableGlobe::deinitialize() {
-    _distanceSwitch.deinitialize();
+void RenderableGlobe::deinitializeGL() {
+    _distanceSwitch.deinitializeGL();
 }
 
 bool RenderableGlobe::isReady() const {

modules/globebrowsing/globes/renderableglobe.h

@@ -81,8 +81,8 @@ public:
     RenderableGlobe(const ghoul::Dictionary& dictionary);
     ~RenderableGlobe() = default;
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
     bool isReady() const override;
 
     void render(const RenderData& data, RendererTasks& rendererTask) override;

modules/globebrowsing/other/distanceswitch.cpp

@@ -37,6 +37,13 @@ bool DistanceSwitch::initialize() {
     return true;
 }
 
+bool DistanceSwitch::initializeGL() {
+    for (unsigned int i = 0; i < _renderables.size(); ++i) {
+        _renderables[i]->initializeGL();
+    }
+    return true;
+}
+
 bool DistanceSwitch::deinitialize() {
     for (unsigned int i = 0; i < _renderables.size(); ++i) {
         _renderables[i]->deinitialize();
@@ -44,6 +51,13 @@ bool DistanceSwitch::deinitialize() {
     return true;
 }
 
+bool DistanceSwitch::deinitializeGL() {
+    for (unsigned int i = 0; i < _renderables.size(); ++i) {
+        _renderables[i]->deinitializeGL();
+    }
+    return true;
+}
+
 void DistanceSwitch::render(const RenderData& data, RendererTasks& tasks) {
     const double distanceToCamera =
         distance(data.camera.positionVec3(), data.modelTransform.translation);

modules/globebrowsing/other/distanceswitch.h

@@ -46,7 +46,9 @@ public:
     ~DistanceSwitch();
 
     bool initialize();
+    bool initializeGL();
     bool deinitialize();
+    bool deinitializeGL();
 
     /**
      * Picks the first Renderable with the associated maxDistance greater than the 

modules/kameleonvolume/rendering/renderablekameleonvolume.cpp

@@ -251,7 +251,7 @@ RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dict
     
 RenderableKameleonVolume::~RenderableKameleonVolume() {}
 
-void RenderableKameleonVolume::initialize() {
+void RenderableKameleonVolume::initializeGL() {
     load();
     
     _volumeTexture->uploadTexture();
@@ -443,7 +443,7 @@ void RenderableKameleonVolume::storeRaw(const std::string& path) {
     writer.write(*_rawVolume);
 }
     
-void RenderableKameleonVolume::deinitialize() {
+void RenderableKameleonVolume::deinitializeGL() {
     if (_raycaster) {
         OsEng.renderEngine().raycasterManager().detachRaycaster(*_raycaster.get());
         _raycaster = nullptr;

modules/kameleonvolume/rendering/renderablekameleonvolume.h

@@ -49,8 +49,8 @@ public:
     RenderableKameleonVolume(const ghoul::Dictionary& dictionary);
     ~RenderableKameleonVolume();
     
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
     bool isReady() const override;
     void render(const RenderData& data, RendererTasks& tasks) override;
     void update(const UpdateData& data) override;

modules/multiresvolume/rendering/renderablemultiresvolume.cpp

@@ -419,7 +419,7 @@ bool RenderableMultiresVolume::setSelectorType(Selector selector) {
     return false;
 }
 
-void RenderableMultiresVolume::initialize() {
+void RenderableMultiresVolume::initializeGL() {
     bool success = _tsp && _tsp->load();
 
     unsigned int maxNumBricks = _tsp->header().xNumBricks_ * _tsp->header().yNumBricks_ * _tsp->header().zNumBricks_;
@@ -481,7 +481,7 @@ void RenderableMultiresVolume::initialize() {
     }
 }
 
-void RenderableMultiresVolume::deinitialize() {
+void RenderableMultiresVolume::deinitializeGL() {
     _tsp = nullptr;
     _transferFunction = nullptr;
 }

modules/multiresvolume/rendering/renderablemultiresvolume.h

@@ -68,8 +68,8 @@ public:
     bool setSelectorType(Selector selector);
     bool initializeSelector();
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/space/rendering/renderableconstellationbounds.cpp

@@ -195,7 +195,7 @@ RenderableConstellationBounds::RenderableConstellationBounds(
     }
 }
 
-void RenderableConstellationBounds::initialize() {
+void RenderableConstellationBounds::initializeGL() {
     _program = OsEng.renderEngine().buildRenderProgram(
         "ConstellationBounds",
         "${MODULE_SPACE}/shaders/constellationbounds_vs.glsl",
@@ -222,7 +222,7 @@ void RenderableConstellationBounds::initialize() {
     glBindVertexArray(0);
 }
 
-void RenderableConstellationBounds::deinitialize() {
+void RenderableConstellationBounds::deinitializeGL() {
     glDeleteBuffers(1, &_vbo);
     _vbo = 0;
     glDeleteVertexArrays(1, &_vao);

modules/space/rendering/renderableconstellationbounds.h

@@ -51,8 +51,8 @@ class RenderableConstellationBounds : public Renderable {
 public:
     RenderableConstellationBounds(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/space/rendering/renderableplanet.cpp

@@ -333,7 +333,7 @@ RenderablePlanet::RenderablePlanet(const ghoul::Dictionary& dictionary)
     }
 }
 
-void RenderablePlanet::initialize() {
+void RenderablePlanet::initializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
 
     if (_programObject == nullptr && _shadowEnabled && _hasNightTexture) {
@@ -375,7 +375,7 @@ void RenderablePlanet::initialize() {
     loadTexture();
 }
 
-void RenderablePlanet::deinitialize() {
+void RenderablePlanet::deinitializeGL() {
     if (_geometry) {
         _geometry->deinitialize();
         _geometry = nullptr;

modules/space/rendering/renderableplanet.h

@@ -68,8 +68,8 @@ public:
 public:
     RenderablePlanet(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
     bool isReady() const override;
 
     void render(const RenderData& data, RendererTasks& rendererTask) override;

modules/space/rendering/renderablerings.cpp

@@ -184,7 +184,7 @@ bool RenderableRings::isReady() const {
     return _shader && _texture;
 }
 
-void RenderableRings::initialize() {
+void RenderableRings::initializeGL() {
     if (!_shader) {
         RenderEngine& renderEngine = OsEng.renderEngine();
         _shader = renderEngine.buildRenderProgram("RingProgram",
@@ -202,7 +202,7 @@ void RenderableRings::initialize() {
     loadTexture();
 }
 
-void RenderableRings::deinitialize() {
+void RenderableRings::deinitializeGL() {
     glDeleteVertexArrays(1, &_quad);
     _quad = 0;
 

modules/space/rendering/renderablerings.h

@@ -46,8 +46,8 @@ class RenderableRings : public Renderable {
 public:
     RenderableRings(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/space/rendering/renderablestars.cpp

@@ -288,7 +288,7 @@ bool RenderableStars::isReady() const {
     return (_program != nullptr) && (!_fullData.empty());
 }
 
-void RenderableStars::initialize() {
+void RenderableStars::initializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     _program = renderEngine.buildRenderProgram("Star",
         "${MODULE_SPACE}/shaders/star_vs.glsl",
@@ -301,7 +301,7 @@ void RenderableStars::initialize() {
     }
 }
 
-void RenderableStars::deinitialize() {
+void RenderableStars::deinitializeGL() {
     glDeleteBuffers(1, &_vbo);
     _vbo = 0;
     glDeleteVertexArrays(1, &_vao);

modules/space/rendering/renderablestars.h

@@ -48,8 +48,8 @@ public:
     explicit RenderableStars(const ghoul::Dictionary& dictionary);
     ~RenderableStars();
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/spacecraftinstruments/rendering/renderablecrawlingline.cpp

@@ -135,7 +135,7 @@ bool RenderableCrawlingLine::isReady() const {
     return (_program != nullptr);
 }
 
-void RenderableCrawlingLine::initialize() {
+void RenderableCrawlingLine::initializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     _program = renderEngine.buildRenderProgram(
         "RenderableCrawlingLine",
@@ -166,7 +166,7 @@ void RenderableCrawlingLine::initialize() {
     glBindVertexArray(0);
 }
 
-void RenderableCrawlingLine::deinitialize(){
+void RenderableCrawlingLine::deinitializeGL() {
     glDeleteVertexArrays(1, &_vao);
     _vao = 0;
     glDeleteBuffers(1, &_vbo);

modules/spacecraftinstruments/rendering/renderablecrawlingline.h

@@ -38,8 +38,8 @@ class RenderableCrawlingLine : public Renderable {
 public:
     RenderableCrawlingLine(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/spacecraftinstruments/rendering/renderablefov.cpp

@@ -297,7 +297,7 @@ RenderableFov::RenderableFov(const ghoul::Dictionary& dictionary)
     addProperty(_colors.square);
 }
 
-void RenderableFov::initialize() {
+void RenderableFov::initializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     _programObject = renderEngine.buildRenderProgram(
         "FovProgram",
@@ -409,7 +409,7 @@ void RenderableFov::initialize() {
     glBindVertexArray(0);
 }
 
-void RenderableFov::deinitialize() {
+void RenderableFov::deinitializeGL() {
     OsEng.renderEngine().removeRenderProgram(_programObject);
     _programObject = nullptr;
 

modules/spacecraftinstruments/rendering/renderablefov.h

@@ -49,8 +49,8 @@ class RenderableFov : public Renderable {
 public:
     RenderableFov(const ghoul::Dictionary& dictionary);
     
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp

@@ -180,7 +180,7 @@ bool RenderableModelProjection::isReady() const {
     return ready;
 }
 
-void RenderableModelProjection::initialize() {
+void RenderableModelProjection::initializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     _programObject = renderEngine.buildRenderProgram("ModelShader",
         "${MODULE_SPACECRAFTINSTRUMENTS}/shaders/renderableModel_vs.glsl",
@@ -207,7 +207,7 @@ void RenderableModelProjection::initialize() {
     setBoundingSphere(bs); // ignore bounding sphere set by geometry.
 }
 
-void RenderableModelProjection::deinitialize() {
+void RenderableModelProjection::deinitializeGL() {
     if (_geometry) {
         _geometry->deinitialize();
     }

modules/spacecraftinstruments/rendering/renderablemodelprojection.h

@@ -55,8 +55,8 @@ public:
     RenderableModelProjection(const ghoul::Dictionary& dictionary);
     ~RenderableModelProjection();
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp

@@ -94,7 +94,7 @@ bool RenderablePlaneProjection::isReady() const {
     return _shader && _texture;
 }
 
-void RenderablePlaneProjection::initialize() {
+void RenderablePlaneProjection::initializeGL() {
     glGenVertexArrays(1, &_quad); // generate array
     glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
     
@@ -110,7 +110,7 @@ void RenderablePlaneProjection::initialize() {
     loadTexture();
 }
 
-void RenderablePlaneProjection::deinitialize() {
+void RenderablePlaneProjection::deinitializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     if (_shader) {
         renderEngine.removeRenderProgram(_shader);

modules/spacecraftinstruments/rendering/renderableplaneprojection.h

@@ -55,8 +55,8 @@ public:
     RenderablePlaneProjection(const ghoul::Dictionary& dictionary);
     ~RenderablePlaneProjection();
     
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 

modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp

@@ -223,7 +223,7 @@ RenderablePlanetProjection::RenderablePlanetProjection(const ghoul::Dictionary&
 
 RenderablePlanetProjection::~RenderablePlanetProjection() {}
 
-void RenderablePlanetProjection::initialize() {
+void RenderablePlanetProjection::initializeGL() {
     _programObject = OsEng.renderEngine().buildRenderProgram(
         "projectiveProgram",
         "${MODULE_SPACECRAFTINSTRUMENTS}/shaders/renderablePlanet_vs.glsl",
@@ -273,7 +273,7 @@ void RenderablePlanetProjection::initialize() {
     glBindVertexArray(0);
 }
 
-void RenderablePlanetProjection::deinitialize() {
+void RenderablePlanetProjection::deinitializeGL() {
     _projectionComponent.deinitialize();
     _baseTexture = nullptr;
     _geometry = nullptr;

modules/spacecraftinstruments/rendering/renderableplanetprojection.h

@@ -44,8 +44,8 @@ public:
     RenderablePlanetProjection(const ghoul::Dictionary& dictionary);
     ~RenderablePlanetProjection();
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
     bool isReady() const override;
 
     void render(const RenderData& data, RendererTasks& rendererTask) override;
@@ -58,7 +58,6 @@ protected:
     bool loadTextures();
     void attitudeParameters(double time);
 
-
 private:
     void imageProjectGPU(std::shared_ptr<ghoul::opengl::Texture> projectionTexture);
 

modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp

@@ -260,7 +260,7 @@ RenderableShadowCylinder::RenderableShadowCylinder(const ghoul::Dictionary& dict
     _aberration = static_cast<int>(aberration.type);
 }
 
-void RenderableShadowCylinder::initialize() {
+void RenderableShadowCylinder::initializeGL() {
     glGenVertexArrays(1, &_vao);
     glGenBuffers(1, &_vbo);
 
@@ -272,7 +272,7 @@ void RenderableShadowCylinder::initialize() {
     );
 }
 
-void RenderableShadowCylinder::deinitialize() {
+void RenderableShadowCylinder::deinitializeGL() {
     RenderEngine& renderEngine = OsEng.renderEngine();
     if (_shader) {
         renderEngine.removeRenderProgram(_shader);

modules/spacecraftinstruments/rendering/renderableshadowcylinder.h

@@ -50,8 +50,8 @@ class RenderableShadowCylinder : public Renderable {
 public:
     RenderableShadowCylinder(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
     void render(const RenderData& data, RendererTasks& rendererTask) override;

modules/toyvolume/rendering/renderabletoyvolume.cpp

@@ -69,7 +69,7 @@ RenderableToyVolume::RenderableToyVolume(const ghoul::Dictionary& dictionary)
     
 RenderableToyVolume::~RenderableToyVolume() {}
 
-void RenderableToyVolume::initialize() {
+void RenderableToyVolume::initializeGL() {
     _raycaster = std::make_unique<ToyVolumeRaycaster>(_color);
     _raycaster->initialize();
 
@@ -94,7 +94,7 @@ void RenderableToyVolume::initialize() {
     addProperty(_color);
 }
     
-void RenderableToyVolume::deinitialize() {
+void RenderableToyVolume::deinitializeGL() {
     if (_raycaster) {
         OsEng.renderEngine().raycasterManager().detachRaycaster(*_raycaster.get());
         _raycaster = nullptr;

modules/toyvolume/rendering/renderabletoyvolume.h

@@ -44,8 +44,8 @@ public:
     RenderableToyVolume(const ghoul::Dictionary& dictionary);
     ~RenderableToyVolume();
     
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
     bool isReady() const override;
     void render(const RenderData& data, RendererTasks& tasks) override;
     void update(const UpdateData& data) override;

modules/volume/rendering/renderabletimevaryingvolume.cpp

@@ -124,7 +124,7 @@ RenderableTimeVaryingVolume::RenderableTimeVaryingVolume(const ghoul::Dictionary
     
 RenderableTimeVaryingVolume::~RenderableTimeVaryingVolume() {}
 
-void RenderableTimeVaryingVolume::initialize() {
+void RenderableTimeVaryingVolume::initializeGL() {
 
     using RawPath = ghoul::filesystem::Directory::RawPath;
     ghoul::filesystem::Directory sequenceDir(_sourceDirectory, RawPath::Yes);
@@ -360,7 +360,7 @@ bool RenderableTimeVaryingVolume::isReady() const {
 }
 
 
-void RenderableTimeVaryingVolume::deinitialize() {
+void RenderableTimeVaryingVolume::deinitializeGL() {
     if (_raycaster) {
         OsEng.renderEngine().raycasterManager().detachRaycaster(*_raycaster.get());
         _raycaster = nullptr;

modules/volume/rendering/renderabletimevaryingvolume.h

@@ -48,8 +48,8 @@ public:
     RenderableTimeVaryingVolume(const ghoul::Dictionary& dictionary);
     ~RenderableTimeVaryingVolume();
     
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
     bool isReady() const override;
     void render(const RenderData& data, RendererTasks& tasks) override;
     void update(const UpdateData& data) override;

src/engine/openspaceengine.cpp

@@ -75,6 +75,8 @@
 
 #include <glbinding/callbacks.h>
 
+#include <random>
+
 #if defined(_MSC_VER) && defined(OPENSPACE_ENABLE_VLD)
 #include <vld.h>
 #endif
@@ -613,7 +615,25 @@ void OpenSpaceEngine::loadScene(const std::string& scenePath) {
     _renderEngine->setGlobalBlackOutFactor(0.0);
     _renderEngine->startFading(1, 3.0);
 
-    scene->initialize();
+    // TODO remove after moving OpenGL out of initialize
+    std::atomic_bool initializeFinished = false;
+    std::thread t([scene, &initializeFinished]() {
+        scene->initialize();
+        initializeFinished = true;
+    });
+
+    std::random_device rd; 
+    std::mt19937 gen(rd());
+    std::uniform_real_distribution<> dis(0.0, 1.0);
+    while (!initializeFinished) {
+        glClearColor(dis(gen), dis(gen), dis(gen), 1.0);
+        glClear(ClearBufferMask::GL_COLOR_BUFFER_BIT);
+        std::this_thread::sleep_for(std::chrono::milliseconds(250));
+        _windowWrapper->swapBuffer();
+    }
+        
+    scene->initializeGL();
+
     // Update the scene so that position of objects are set in case they are used in
     // post sync scripts
     _renderEngine->updateScene();

src/engine/wrapper/sgctwindowwrapper.cpp

@@ -258,4 +258,11 @@ void SGCTWindowWrapper::takeScreenshot(bool applyWarping) const {
     sgct::Engine::instance()->takeScreenshot();
 }
 
+void SGCTWindowWrapper::swapBuffer() const {
+    GLFWwindow* w = glfwGetCurrentContext();
+    glfwSwapBuffers(w);
+
+    glfwPollEvents();
+}
+
 } // namespace openspace

src/engine/wrapper/windowwrapper.cpp

@@ -185,4 +185,6 @@ bool WindowWrapper::isSimpleRendering() const {
 
 void WindowWrapper::takeScreenshot(bool) const {}
 
+void WindowWrapper::swapBuffer() const {}
+
 } // namespace openspace

src/rendering/renderable.cpp

@@ -151,8 +151,12 @@ Renderable::~Renderable() {}
 
 void Renderable::initialize() {}
 
+void Renderable::initializeGL() {}
+
 void Renderable::deinitialize() {}
 
+void Renderable::deinitializeGL() {}
+
 void Renderable::setBoundingSphere(float boundingSphere) {
     _boundingSphere = boundingSphere;
 }

src/rendering/screenspacerenderable.cpp

@@ -304,6 +304,10 @@ ScreenSpaceRenderable::ScreenSpaceRenderable(const ghoul::Dictionary& dictionary
 }
 
 bool ScreenSpaceRenderable::initialize() {
+    return true;
+}
+
+bool ScreenSpaceRenderable::initializeGL() {
     _originalViewportSize = OsEng.windowWrapper().currentWindowResolution();
 
     createPlane();
@@ -313,6 +317,10 @@ bool ScreenSpaceRenderable::initialize() {
 }
 
 bool ScreenSpaceRenderable::deinitialize() {
+    return true;
+}
+
+bool ScreenSpaceRenderable::deinitializeGL() {
     glDeleteVertexArrays(1, &_quad);
     _quad = 0;
 

src/scene/scene.cpp

@@ -225,6 +225,18 @@ void Scene::initialize() {
     }
 }
 
+void Scene::initializeGL() {
+    for (SceneGraphNode* node : _topologicallySortedNodes) {
+        try {
+            node->initializeGL();
+        }
+        catch (const ghoul::RuntimeError& e) {
+            LERROR(node->name() << " not initialized.");
+            LERRORC(std::string(_loggerCat) + "(" + e.component + ")", e.what());
+        }
+    }
+}
+
 void Scene::update(const UpdateData& data) {
     for (SceneGraphNode* node : _topologicallySortedNodes) {
         try {

src/scene/scenegraphnode.cpp

@@ -182,11 +182,10 @@ SceneGraphNode::SceneGraphNode()
     }
 {}
 
-SceneGraphNode::~SceneGraphNode() {
-    deinitialize();
-}
+SceneGraphNode::~SceneGraphNode() {}
 
 void SceneGraphNode::initialize() {
+    LDEBUG("Initialize: " << name());
     if (_renderable) {
         _renderable->initialize();
     }
@@ -203,16 +202,24 @@ void SceneGraphNode::initialize() {
     }
 }
 
+void SceneGraphNode::initializeGL() {
+    if (_renderable) {
+        _renderable->initializeGL();
+    }
+}
+
 void SceneGraphNode::deinitialize() {
     LDEBUG("Deinitialize: " << name());
 
     if (_renderable) {
         _renderable->deinitialize();
-        _renderable = nullptr;
     }
-    _children.clear();
+}
 
-    _parent = nullptr;
+void SceneGraphNode::deinitializeGL() {
+    if (_renderable) {
+        _renderable->deinitializeGL();
+    }
 }
 
 void SceneGraphNode::traversePreOrder(std::function<void(SceneGraphNode*)> fn) {