diff --git a/apps/app_demo/source/scenes/AppDemoScene2Dand3DText.h b/apps/app_demo/source/scenes/AppDemoScene2Dand3DText.h
index 54ef29aa..7e64fb1d 100644
--- a/apps/app_demo/source/scenes/AppDemoScene2Dand3DText.h
+++ b/apps/app_demo/source/scenes/AppDemoScene2Dand3DText.h
@@ -21,7 +21,24 @@ class AppDemoScene2Dand3DText : public SLScene
 {
 public:
     AppDemoScene2Dand3DText();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 };
 //-----------------------------------------------------------------------------
diff --git a/apps/app_demo/source/scenes/AppDemoSceneAnimNode.h b/apps/app_demo/source/scenes/AppDemoSceneAnimNode.h
index 81ba1850..806ee395 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneAnimNode.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneAnimNode.h
@@ -21,7 +21,24 @@ class AppDemoSceneAnimNode : public SLScene
 {
 public:
     AppDemoSceneAnimNode();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneAnimNodeMass.h b/apps/app_demo/source/scenes/AppDemoSceneAnimNodeMass.h
index abef0da2..9b5376a7 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneAnimNodeMass.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneAnimNodeMass.h
@@ -21,7 +21,24 @@ class AppDemoSceneAnimNodeMass : public SLScene
 {
 public:
     AppDemoSceneAnimNodeMass();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneAnimSkinned.h b/apps/app_demo/source/scenes/AppDemoSceneAnimSkinned.h
index 535e81c5..3261517d 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneAnimSkinned.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneAnimSkinned.h
@@ -21,7 +21,24 @@ class AppDemoSceneAnimSkinned : public SLScene
 {
 public:
     AppDemoSceneAnimSkinned();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneAnimSkinnedMass.h b/apps/app_demo/source/scenes/AppDemoSceneAnimSkinnedMass.h
index 192beee8..7603a9ff 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneAnimSkinnedMass.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneAnimSkinnedMass.h
@@ -21,7 +21,24 @@ class AppDemoSceneAnimSkinnedMass : public SLScene
 {
 public:
     AppDemoSceneAnimSkinnedMass();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneAnimSkinnedMass2.h b/apps/app_demo/source/scenes/AppDemoSceneAnimSkinnedMass2.h
index 5271e39b..96728086 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneAnimSkinnedMass2.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneAnimSkinnedMass2.h
@@ -21,7 +21,24 @@ class AppDemoSceneAnimSkinnedMass2 : public SLScene
 {
 public:
     AppDemoSceneAnimSkinnedMass2();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneEmpty.h b/apps/app_demo/source/scenes/AppDemoSceneEmpty.h
index 0f9f7769..91526910 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneEmpty.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneEmpty.h
@@ -20,7 +20,24 @@ class AppDemoSceneEmpty : public SLScene
 {
 public:
     AppDemoSceneEmpty();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 };
 //-----------------------------------------------------------------------------
diff --git a/apps/app_demo/source/scenes/AppDemoSceneErlebARAugustaTmpTht.h b/apps/app_demo/source/scenes/AppDemoSceneErlebARAugustaTmpTht.h
index e752532b..3d3c3fe2 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneErlebARAugustaTmpTht.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneErlebARAugustaTmpTht.h
@@ -21,7 +21,24 @@ class AppDemoSceneErlebARAugustaTmpTht : public SLScene
 {
 public:
     AppDemoSceneErlebARAugustaTmpTht();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumAmphitheater.h b/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumAmphitheater.h
index f2609730..7d2adbe5 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumAmphitheater.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumAmphitheater.h
@@ -21,7 +21,24 @@ class AppDemoSceneErlebARAventicumAmphitheater : public SLScene
 {
 public:
     AppDemoSceneErlebARAventicumAmphitheater();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumCigognier.h b/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumCigognier.h
index f10fb1c9..d5cc15bf 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumCigognier.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumCigognier.h
@@ -21,7 +21,24 @@ class AppDemoSceneErlebARAventicumCigognier : public SLScene
 {
 public:
     AppDemoSceneErlebARAventicumCigognier();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumTheater.h b/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumTheater.h
index c676b6f3..44408e82 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumTheater.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneErlebARAventicumTheater.h
@@ -21,7 +21,24 @@ class AppDemoSceneErlebARAventicumTheater : public SLScene
 {
 public:
     AppDemoSceneErlebARAventicumTheater();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneErlebARBielBFH.h b/apps/app_demo/source/scenes/AppDemoSceneErlebARBielBFH.h
index d18efb34..0cd58591 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneErlebARBielBFH.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneErlebARBielBFH.h
@@ -21,7 +21,24 @@ class AppDemoSceneErlebARBielBFH : public SLScene
 {
 public:
     AppDemoSceneErlebARBielBFH();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneErlebARChristoffel.h b/apps/app_demo/source/scenes/AppDemoSceneErlebARChristoffel.h
index 483983d6..0e031e8b 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneErlebARChristoffel.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneErlebARChristoffel.h
@@ -21,7 +21,24 @@ class AppDemoSceneErlebARChristoffel : public SLScene
 {
 public:
     AppDemoSceneErlebARChristoffel();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneErlebARSutz.h b/apps/app_demo/source/scenes/AppDemoSceneErlebARSutz.h
index c201a826..ecdcc9e8 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneErlebARSutz.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneErlebARSutz.h
@@ -21,7 +21,24 @@ class AppDemoSceneErlebARSutz : public SLScene
 {
 public:
     AppDemoSceneErlebARSutz();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneFrustum.h b/apps/app_demo/source/scenes/AppDemoSceneFrustum.h
index 9024d5d8..eab3a64b 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneFrustum.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneFrustum.h
@@ -21,7 +21,24 @@ class AppDemoSceneFrustum : public SLScene
 {
 public:
     AppDemoSceneFrustum();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneGLTF.h b/apps/app_demo/source/scenes/AppDemoSceneGLTF.h
index 3f601c92..91e43b6b 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneGLTF.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneGLTF.h
@@ -22,7 +22,24 @@ class AppDemoSceneGLTF : public SLScene
 public:
     AppDemoSceneGLTF(SLSceneID sceneID);
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneJansUniverse.h b/apps/app_demo/source/scenes/AppDemoSceneJansUniverse.h
index 42b18fe4..3a6895db 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneJansUniverse.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneJansUniverse.h
@@ -22,7 +22,24 @@ class AppDemoSceneJansUniverse : public SLScene
 {
 public:
     AppDemoSceneJansUniverse();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
     void addUniverseLevel(SLAssetManager* am,
                           SLScene*        s,
diff --git a/apps/app_demo/source/scenes/AppDemoSceneLargeModel.h b/apps/app_demo/source/scenes/AppDemoSceneLargeModel.h
index 029e312a..257c0bb6 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneLargeModel.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneLargeModel.h
@@ -21,7 +21,24 @@ class AppDemoSceneLargeModel : public SLScene
 {
 public:
     AppDemoSceneLargeModel();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneLevelOfDetail.h b/apps/app_demo/source/scenes/AppDemoSceneLevelOfDetail.h
index 07f9f59b..97594e74 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneLevelOfDetail.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneLevelOfDetail.h
@@ -21,7 +21,24 @@ class AppDemoSceneLevelOfDetail : public SLScene
 {
 public:
     AppDemoSceneLevelOfDetail(SLSceneID sceneID);
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneLotsOfNodes.h b/apps/app_demo/source/scenes/AppDemoSceneLotsOfNodes.h
index fc4a171a..d60eda9f 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneLotsOfNodes.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneLotsOfNodes.h
@@ -22,7 +22,24 @@ class AppDemoSceneLotsOfNodes : public SLScene
 {
 public:
     AppDemoSceneLotsOfNodes();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneMeshLoad.h b/apps/app_demo/source/scenes/AppDemoSceneMeshLoad.h
index d7ed81df..b31409fe 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneMeshLoad.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneMeshLoad.h
@@ -21,7 +21,24 @@ class AppDemoSceneMeshLoad : public SLScene
 {
 public:
     AppDemoSceneMeshLoad();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneMinimal.h b/apps/app_demo/source/scenes/AppDemoSceneMinimal.h
index 3f2df703..3338d529 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneMinimal.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneMinimal.h
@@ -21,7 +21,24 @@ class AppDemoSceneMinimal : public SLScene
 {
 public:
     AppDemoSceneMinimal();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneParticleComplexFire.h b/apps/app_demo/source/scenes/AppDemoSceneParticleComplexFire.h
index fc987301..babf61ae 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneParticleComplexFire.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneParticleComplexFire.h
@@ -21,7 +21,24 @@ class AppDemoSceneParticleComplexFire : public SLScene
 {
 public:
     AppDemoSceneParticleComplexFire(SLSceneID sceneID);
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
     SLNode* createComplexFire(SLAssetManager* am,
diff --git a/apps/app_demo/source/scenes/AppDemoSceneParticleDustStorm.h b/apps/app_demo/source/scenes/AppDemoSceneParticleDustStorm.h
index 459b9e9d..c09e974b 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneParticleDustStorm.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneParticleDustStorm.h
@@ -21,7 +21,24 @@ class AppDemoSceneParticleDustStorm : public SLScene
 {
 public:
     AppDemoSceneParticleDustStorm();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneParticleFountain.h b/apps/app_demo/source/scenes/AppDemoSceneParticleFountain.h
index ac5bb2bb..380c0b46 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneParticleFountain.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneParticleFountain.h
@@ -21,7 +21,24 @@ class AppDemoSceneParticleFountain : public SLScene
 {
 public:
     AppDemoSceneParticleFountain();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneParticleMany.h b/apps/app_demo/source/scenes/AppDemoSceneParticleMany.h
index 5cbe9145..a1b5890d 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneParticleMany.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneParticleMany.h
@@ -21,7 +21,24 @@ class AppDemoSceneParticleMany : public SLScene
 {
 public:
     AppDemoSceneParticleMany();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneParticleRingOfFire.h b/apps/app_demo/source/scenes/AppDemoSceneParticleRingOfFire.h
index af717bc4..0fcf91ef 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneParticleRingOfFire.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneParticleRingOfFire.h
@@ -21,7 +21,24 @@ class AppDemoSceneParticleRingOfFire : public SLScene
 {
 public:
     AppDemoSceneParticleRingOfFire();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneParticleSimple.h b/apps/app_demo/source/scenes/AppDemoSceneParticleSimple.h
index d0445375..219b8f17 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneParticleSimple.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneParticleSimple.h
@@ -21,7 +21,24 @@ class AppDemoSceneParticleSimple : public SLScene
 {
 public:
     AppDemoSceneParticleSimple();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneParticleSun.h b/apps/app_demo/source/scenes/AppDemoSceneParticleSun.h
index c5359a72..003d3ffb 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneParticleSun.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneParticleSun.h
@@ -21,7 +21,24 @@ class AppDemoSceneParticleSun : public SLScene
 {
 public:
     AppDemoSceneParticleSun();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoScenePointClouds.h b/apps/app_demo/source/scenes/AppDemoScenePointClouds.h
index eb4a1bad..34a43221 100644
--- a/apps/app_demo/source/scenes/AppDemoScenePointClouds.h
+++ b/apps/app_demo/source/scenes/AppDemoScenePointClouds.h
@@ -21,7 +21,24 @@ class AppDemoScenePointClouds : public SLScene
 {
 public:
     AppDemoScenePointClouds();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneRTDoF.h b/apps/app_demo/source/scenes/AppDemoSceneRTDoF.h
index 81ebafcd..b5f2f2f3 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneRTDoF.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneRTDoF.h
@@ -21,7 +21,24 @@ class AppDemoSceneRTDoF : public SLScene
 {
 public:
     AppDemoSceneRTDoF();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneRTLens.h b/apps/app_demo/source/scenes/AppDemoSceneRTLens.h
index 313f59e0..20ea7475 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneRTLens.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneRTLens.h
@@ -21,7 +21,24 @@ class AppDemoSceneRTLens : public SLScene
 {
 public:
     AppDemoSceneRTLens();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneRTMuttenzerBox.h b/apps/app_demo/source/scenes/AppDemoSceneRTMuttenzerBox.h
index fa767580..ece92d3a 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneRTMuttenzerBox.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneRTMuttenzerBox.h
@@ -21,7 +21,24 @@ class AppDemoSceneRTMuttenzerBox : public SLScene
 {
 public:
     AppDemoSceneRTMuttenzerBox();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneRevolver.h b/apps/app_demo/source/scenes/AppDemoSceneRevolver.h
index 790bf26c..375bde32 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneRevolver.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneRevolver.h
@@ -21,7 +21,24 @@ class AppDemoSceneRevolver : public SLScene
 {
 public:
     AppDemoSceneRevolver();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneRobot.h b/apps/app_demo/source/scenes/AppDemoSceneRobot.h
index 4ae0a919..bfcd7c83 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneRobot.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneRobot.h
@@ -22,7 +22,24 @@ class AppDemoSceneRobot : public SLScene
 public:
     AppDemoSceneRobot();
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShaderBlinn.h b/apps/app_demo/source/scenes/AppDemoSceneShaderBlinn.h
index d4982115..47940fd4 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShaderBlinn.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShaderBlinn.h
@@ -23,7 +23,24 @@ class AppDemoSceneShaderBlinn : public SLScene
     AppDemoSceneShaderBlinn(SLstring name,
                             bool     perVertex);
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShaderBump.h b/apps/app_demo/source/scenes/AppDemoSceneShaderBump.h
index b103f490..733134f9 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShaderBump.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShaderBump.h
@@ -22,7 +22,24 @@ class AppDemoSceneShaderBump : public SLScene
 public:
     AppDemoSceneShaderBump();
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShaderCook.h b/apps/app_demo/source/scenes/AppDemoSceneShaderCook.h
index c3e7b539..98927199 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShaderCook.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShaderCook.h
@@ -22,7 +22,24 @@ class AppDemoSceneShaderCook : public SLScene
 public:
     AppDemoSceneShaderCook();
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShaderEarth.h b/apps/app_demo/source/scenes/AppDemoSceneShaderEarth.h
index c67129cd..34239b9c 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShaderEarth.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShaderEarth.h
@@ -22,7 +22,24 @@ class AppDemoSceneShaderEarth : public SLScene
 public:
     AppDemoSceneShaderEarth();
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShaderIBL.h b/apps/app_demo/source/scenes/AppDemoSceneShaderIBL.h
index 12aabac4..fce51ff3 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShaderIBL.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShaderIBL.h
@@ -22,7 +22,24 @@ class AppDemoSceneShaderIBL : public SLScene
 public:
     AppDemoSceneShaderIBL();
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShaderParallax.h b/apps/app_demo/source/scenes/AppDemoSceneShaderParallax.h
index 1e5abadc..5fe67606 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShaderParallax.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShaderParallax.h
@@ -22,7 +22,24 @@ class AppDemoSceneShaderParallax : public SLScene
 public:
     AppDemoSceneShaderParallax();
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShaderSkybox.h b/apps/app_demo/source/scenes/AppDemoSceneShaderSkybox.h
index c96c31a4..9f2ffdb1 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShaderSkybox.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShaderSkybox.h
@@ -22,7 +22,24 @@ class AppDemoSceneShaderSkybox : public SLScene
 public:
     AppDemoSceneShaderSkybox();
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShaderWave.h b/apps/app_demo/source/scenes/AppDemoSceneShaderWave.h
index 15bf2941..2a3c358d 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShaderWave.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShaderWave.h
@@ -22,7 +22,24 @@ class AppDemoSceneShaderWave : public SLScene
 public:
     AppDemoSceneShaderWave();
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShadowBasic.h b/apps/app_demo/source/scenes/AppDemoSceneShadowBasic.h
index 39285916..105bed06 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShadowBasic.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShadowBasic.h
@@ -21,7 +21,24 @@ class AppDemoSceneShadowBasic : public SLScene
 {
 public:
     AppDemoSceneShadowBasic();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 };
 //-----------------------------------------------------------------------------
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShadowCascaded.h b/apps/app_demo/source/scenes/AppDemoSceneShadowCascaded.h
index dfab062c..57930042 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShadowCascaded.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShadowCascaded.h
@@ -21,7 +21,24 @@ class AppDemoSceneShadowCascaded : public SLScene
 {
 public:
     AppDemoSceneShadowCascaded();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShadowLightPoint.h b/apps/app_demo/source/scenes/AppDemoSceneShadowLightPoint.h
index 6f27bbd0..cd0c4704 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShadowLightPoint.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShadowLightPoint.h
@@ -21,7 +21,24 @@ class AppDemoSceneShadowLightPoint : public SLScene
 {
 public:
     AppDemoSceneShadowLightPoint();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 };
 //-----------------------------------------------------------------------------
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShadowLightSpot.h b/apps/app_demo/source/scenes/AppDemoSceneShadowLightSpot.h
index f811bad8..253226d9 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShadowLightSpot.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShadowLightSpot.h
@@ -21,7 +21,24 @@ class AppDemoSceneShadowLightSpot : public SLScene
 {
 public:
     AppDemoSceneShadowLightSpot();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 };
 //-----------------------------------------------------------------------------
diff --git a/apps/app_demo/source/scenes/AppDemoSceneShadowLightTypes.h b/apps/app_demo/source/scenes/AppDemoSceneShadowLightTypes.h
index 2fb1dcb2..c249b28b 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneShadowLightTypes.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneShadowLightTypes.h
@@ -21,7 +21,24 @@ class AppDemoSceneShadowLightTypes : public SLScene
 {
 public:
     AppDemoSceneShadowLightTypes();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneSuzanne.h b/apps/app_demo/source/scenes/AppDemoSceneSuzanne.h
index ae59f878..363121f2 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneSuzanne.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneSuzanne.h
@@ -27,7 +27,24 @@ class AppDemoSceneSuzanne : public SLScene
                         bool     shadowMapping,
                         bool     environmentMapping);
 
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneTextureBlend.h b/apps/app_demo/source/scenes/AppDemoSceneTextureBlend.h
index 5a296b38..32a309a2 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneTextureBlend.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneTextureBlend.h
@@ -21,7 +21,24 @@ class AppDemoSceneTextureBlend : public SLScene
 {
 public:
     AppDemoSceneTextureBlend();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneTextureCompression.h b/apps/app_demo/source/scenes/AppDemoSceneTextureCompression.h
index f58b980e..ac7a87f6 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneTextureCompression.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneTextureCompression.h
@@ -21,7 +21,24 @@ class AppDemoSceneTextureCompression : public SLScene
 {
 public:
     AppDemoSceneTextureCompression();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneTextureFilter.h b/apps/app_demo/source/scenes/AppDemoSceneTextureFilter.h
index 1462d7d7..cbd02ee6 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneTextureFilter.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneTextureFilter.h
@@ -21,7 +21,24 @@ class AppDemoSceneTextureFilter : public SLScene
 {
 public:
     AppDemoSceneTextureFilter();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVideoSensorAR.h b/apps/app_demo/source/scenes/AppDemoSceneVideoSensorAR.h
index 5f61df3e..7b5731c3 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVideoSensorAR.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVideoSensorAR.h
@@ -21,7 +21,24 @@ class AppDemoSceneVideoSensorAR : public SLScene
 {
 public:
     AppDemoSceneVideoSensorAR();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVideoTexture.h b/apps/app_demo/source/scenes/AppDemoSceneVideoTexture.h
index 41b6bb77..48861440 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVideoTexture.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVideoTexture.h
@@ -21,7 +21,24 @@ class AppDemoSceneVideoTexture : public SLScene
 {
 public:
     AppDemoSceneVideoTexture(SLSceneID sid);
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackAruco.h b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackAruco.h
index 08b0cbfc..78d2708f 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackAruco.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackAruco.h
@@ -21,7 +21,24 @@ class AppDemoSceneVideoTrackAruco : public SLScene
 {
 public:
     AppDemoSceneVideoTrackAruco(SLSceneID sid);
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackChessboard.h b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackChessboard.h
index 6849d579..a8056d9d 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackChessboard.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackChessboard.h
@@ -21,7 +21,24 @@ class AppDemoSceneVideoTrackChessboard : public SLScene
 {
 public:
     AppDemoSceneVideoTrackChessboard(SLSceneID sid);
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackFace.h b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackFace.h
index 4debd827..3495b720 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackFace.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackFace.h
@@ -21,7 +21,24 @@ class AppDemoSceneVideoTrackFace : public SLScene
 {
 public:
     AppDemoSceneVideoTrackFace(SLSceneID sid);
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackFeatures.h b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackFeatures.h
index 6a0e545c..c5ec566e 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackFeatures.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackFeatures.h
@@ -21,7 +21,24 @@ class AppDemoSceneVideoTrackFeatures : public SLScene
 {
 public:
     AppDemoSceneVideoTrackFeatures();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackMediapipe.h b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackMediapipe.h
index f5d323a9..a84b86ec 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackMediapipe.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackMediapipe.h
@@ -21,7 +21,24 @@ class AppDemoSceneVideoTrackMediapipe : public SLScene
 {
 public:
     AppDemoSceneVideoTrackMediapipe();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackWAI.h b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackWAI.h
index 4ec28933..c9aadd42 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVideoTrackWAI.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVideoTrackWAI.h
@@ -21,7 +21,24 @@ class AppDemoSceneVideoTrackWAI : public SLScene
 {
 public:
     AppDemoSceneVideoTrackWAI();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVolumeRayCast.h b/apps/app_demo/source/scenes/AppDemoSceneVolumeRayCast.h
index 08b008c1..27779e68 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVolumeRayCast.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVolumeRayCast.h
@@ -21,7 +21,24 @@ class AppDemoSceneVolumeRayCast : public SLScene
 {
 public:
     AppDemoSceneVolumeRayCast();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneVolumeRayCastLighted.h b/apps/app_demo/source/scenes/AppDemoSceneVolumeRayCastLighted.h
index 685a7540..0e897687 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneVolumeRayCastLighted.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneVolumeRayCastLighted.h
@@ -21,7 +21,24 @@ class AppDemoSceneVolumeRayCastLighted : public SLScene
 {
 public:
     AppDemoSceneVolumeRayCastLighted();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_demo/source/scenes/AppDemoSceneZFighting.h b/apps/app_demo/source/scenes/AppDemoSceneZFighting.h
index d444b532..6aa974fe 100644
--- a/apps/app_demo/source/scenes/AppDemoSceneZFighting.h
+++ b/apps/app_demo/source/scenes/AppDemoSceneZFighting.h
@@ -21,7 +21,24 @@ class AppDemoSceneZFighting : public SLScene
 {
 public:
     AppDemoSceneZFighting();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 };
 //-----------------------------------------------------------------------------
diff --git a/apps/app_minimal/AppMinimalMain.cpp b/apps/app_minimal/AppMinimalMain.cpp
index 4d14a268..9021acd0 100644
--- a/apps/app_minimal/AppMinimalMain.cpp
+++ b/apps/app_minimal/AppMinimalMain.cpp
@@ -28,7 +28,24 @@ class AppMinimalScene : public SLScene
 {
 public:
     AppMinimalScene();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/app_node/AppNodeScene.h b/apps/app_node/AppNodeScene.h
index 87436a03..267515a8 100644
--- a/apps/app_node/AppNodeScene.h
+++ b/apps/app_node/AppNodeScene.h
@@ -18,7 +18,24 @@ class AppNodeScene : public SLScene
 {
 public:
     AppNodeScene();
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     void registerAssetsToLoad(SLAssetLoader& al) override;
+
+    //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     void assemble(SLAssetManager* am, SLSceneView* sv) override;
 
 private:
diff --git a/apps/source/AppCommon.cpp b/apps/source/AppCommon.cpp
index b63d932f..46465231 100644
--- a/apps/source/AppCommon.cpp
+++ b/apps/source/AppCommon.cpp
@@ -1,6 +1,6 @@
 /**
  * \file      AppCommon.cpp
- * \brief     The AppCommon class holds the top-level instances of the app-demo
+ * \brief     The AppCommon class holds the top-level instances for SLProject apps
  * \details   For more info on how to create a new app with SLProject see:
  *            https://github.com/cpvrlab/SLProject4/wiki/Creating-a-New-App
  *            For more info about App framework see: 
@@ -93,18 +93,19 @@ const string AppCommon::CALIB_FTP_DIR   = "calibrations";
 const string AppCommon::PROFILE_FTP_DIR = "profiles";
 
 //-----------------------------------------------------------------------------
-//! Application and Scene creation function
+//! Application creation function
 /*! Writes and inits the static application information and create the single
-instance of the scene. Gets called by the C-interface function slCreateApp.
+instances of SLGLState, SLAssetManager and SLAssetLoader. Gets called by the 
+C-interface function slCreateApp.
 <br>
 <br>
 See examples usages in:
-  - app_demo_slproject/glfw:    AppDemoMainGLFW.cpp   in function main()
-  - app_demo_slproject/android: AppDemoAndroidJNI.cpp in Java_ch_fhnw_comgr_GLES3Lib_onInit()
-  - app_demo_slproject/ios:     ViewController.m      in viewDidLoad()
+  - platforms/android/AppAndroid.cpp in the App::run function
+  - platforms/emscripten/AppEmscripten.cpp in the App::run function
+  - platforms/glfw/AppGLFW.cpp in the App::run function
+  - platforms/ios/ViewController.mm in the viewDidLoad function
 <br>
 /param applicationName The apps name
-/param onSceneLoadCallback C Callback function as void* pointer for the scene creation.
 */
 void AppCommon::createApp(SLstring appName)
 {
@@ -132,6 +133,12 @@ void AppCommon::createApp(SLstring appName)
 #endif
 }
 //-----------------------------------------------------------------------------
+/*! Registers core assets to load async by all apps. Scene specific assets have
+to be loaded async by overriding SLScene::registerAssetsToLoad and 
+SLScene::assemble. Async loading and assembling means that it happens in a 
+parallel thread and that inthere are no OpenGL calls allowed. OpenGL calls are
+only allowed in the main thread.
+*/
 void AppCommon::registerCoreAssetsLoad()
 {
     SLAssetLoader&  al = *AppCommon::assetLoader;
diff --git a/modules/sl/source/SLMaterial.h b/modules/sl/source/SLMaterial.h
index 581e0391..50326b22 100644
--- a/modules/sl/source/SLMaterial.h
+++ b/modules/sl/source/SLMaterial.h
@@ -23,9 +23,8 @@ class SLAssetManager;
 
 //-----------------------------------------------------------------------------
 //! Defines a standard CG material with textures and a shader program
-/*!
- The SLMaterial class defines a material with either the Blinn-Phong (default)
- or the Cook-Torrance reflection) model.<br>
+/** @details The SLMaterial class defines a material with either the 
+ Blinn-Phong (default) or the Cook-Torrance reflection) model.<br>
  <br>
  In the Blinn-Phong reflection model the following parameters get used:<br>
  The ambient, diffuse, specular and emissive color as well as the shininess
@@ -44,6 +43,14 @@ class SLAssetManager;
  shaders (a vertex and fragment shader) gets automatically generated
  according to the reflection model and the material parameters. See
  SLGLProgramGenerated for more details.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this material it means, that OpenGL shader programs in _programs 
+ * and the textures in _textures do not get built until the first frame is
+ * rendered.
 */
 class SLMaterial : public SLObject
 {
diff --git a/modules/sl/source/SLScene.h b/modules/sl/source/SLScene.h
index 7cad43ce..9bcafddb 100644
--- a/modules/sl/source/SLScene.h
+++ b/modules/sl/source/SLScene.h
@@ -54,9 +54,24 @@ class SLScene : public SLObject
     void initOculus(SLstring shaderDir);
 
     //! All assets the should be loaded in parallel must be registered in here.
+    
+    //! All scene specific assets have to be registered for async loading in here.
+    /*! @remark All scene sspecific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there are 
+    no OpenGL calls allowed. OpenGL calls are only allowed in the main thread.*/
     virtual void registerAssetsToLoad(SLAssetLoader& al) {}
 
     //! After parallel loading of the assets the scene gets assembled in here.
+    /*! @remark All scene-specific assets have to be loaded async by overriding 
+    SLScene::registerAssetsToLoad and SLScene::assemble. Async loading and 
+    assembling means that it happens in a parallel thread and that in there 
+    are no OpenGL calls allowed. OpenGL calls are only allowed in the main 
+    thread. It is important that all object instantiations within 
+    SLScene::assemble do NOT call any OpenGL functions (gl*) because they happen 
+    in a parallel thread. All objects that get rendered have to do their 
+    initialization when they are used the first time during rendering in the 
+    main thread.*/
     virtual void assemble(SLAssetManager* am, SLSceneView* sv) {}
 
     // Setters
diff --git a/modules/sl/source/mesh/SLArrow.h b/modules/sl/source/mesh/SLArrow.h
index 0fc6627a..eba35e98 100644
--- a/modules/sl/source/mesh/SLArrow.h
+++ b/modules/sl/source/mesh/SLArrow.h
@@ -13,7 +13,16 @@
 #include <SLRevolver.h>
 
 //-----------------------------------------------------------------------------
-//! SLArrow is creates an arrow mesh based on its SLRevolver methods
+/**
+ * @brief SLArrow is creates an arrow mesh based on its SLRevolver methods
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this SLMesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLArrow : public SLRevolver
 {
 public:
diff --git a/modules/sl/source/mesh/SLBox.h b/modules/sl/source/mesh/SLBox.h
index f4c86874..530ddc29 100644
--- a/modules/sl/source/mesh/SLBox.h
+++ b/modules/sl/source/mesh/SLBox.h
@@ -14,12 +14,19 @@
 #include <SLMesh.h>
 
 //-----------------------------------------------------------------------------
-//! Axis aligned box mesh
-/*!
-The SLBox node draws an axis aligned box from a minimal corner to a maximal
-corner. If the minimal and maximal corner are swapped the normals will point
-inside.
-*/
+/**
+ * @brief Axis aligned box mesh
+ * @details The SLBox node draws an axis aligned box from a minimal corner to 
+ * a maximal corner. If the minimal and maximal corner are swapped the normals 
+ * will point inside.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this SLMesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLBox : public SLMesh
 {
 public:
diff --git a/modules/sl/source/mesh/SLCircle.h b/modules/sl/source/mesh/SLCircle.h
index 55d4fc81..69310cc0 100644
--- a/modules/sl/source/mesh/SLCircle.h
+++ b/modules/sl/source/mesh/SLCircle.h
@@ -13,6 +13,16 @@
 #include <SLPolyline.h>
 
 //-----------------------------------------------------------------------------
+/**
+ * @brief Circle line mesh derived from SLPolyline
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLCircle : public SLPolyline
 {
 public:
diff --git a/modules/sl/source/mesh/SLCone.h b/modules/sl/source/mesh/SLCone.h
index b920a1b8..10d0c869 100644
--- a/modules/sl/source/mesh/SLCone.h
+++ b/modules/sl/source/mesh/SLCone.h
@@ -13,7 +13,16 @@
 #include <SLRevolver.h>
 
 //-----------------------------------------------------------------------------
-//! SLCone creates a cone mesh based on SLRevolver
+/**
+ * @brief SLCone creates a cone mesh based on SLRevolver
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLCone : public SLRevolver
 {
 public:
diff --git a/modules/sl/source/mesh/SLCoordAxis.h b/modules/sl/source/mesh/SLCoordAxis.h
index b66390a6..0de22dc1 100644
--- a/modules/sl/source/mesh/SLCoordAxis.h
+++ b/modules/sl/source/mesh/SLCoordAxis.h
@@ -14,12 +14,19 @@
 #include <SLMesh.h>
 
 //-----------------------------------------------------------------------------
-//! Axis aligned coordinate axis mesh
-/*!
-The SLAxis mesh draws axis aligned arrows to indicate the coordinate system.
-All arrows have unit lenght. The arrow along x,y & z axis have the colors
-red, green & blue.
-*/
+/**
+ * @brief Axis aligned coordinate axis mesh
+ * @details The SLAxis mesh draws axis aligned arrows to indicate the 
+ * coordinate system. All arrows have unit lenght. The arrow along x,y & z 
+ * axis have the colors red, green & blue.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLCoordAxis : public SLMesh
 {
 public:
diff --git a/modules/sl/source/mesh/SLCoordAxisArrow.h b/modules/sl/source/mesh/SLCoordAxisArrow.h
index 61aaed4c..78188b50 100644
--- a/modules/sl/source/mesh/SLCoordAxisArrow.h
+++ b/modules/sl/source/mesh/SLCoordAxisArrow.h
@@ -13,7 +13,16 @@
 #include <SLMesh.h>
 
 //-----------------------------------------------------------------------------
-//! Single arrow for coordinate axis
+/**
+ * @brief  Single arrow for coordinate axis
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLCoordAxisArrow : public SLMesh
 {
 public:
diff --git a/modules/sl/source/mesh/SLCylinder.h b/modules/sl/source/mesh/SLCylinder.h
index 02c1a28d..a953ca6e 100644
--- a/modules/sl/source/mesh/SLCylinder.h
+++ b/modules/sl/source/mesh/SLCylinder.h
@@ -13,7 +13,16 @@
 #include <SLRevolver.h>
 
 //-----------------------------------------------------------------------------
-//! SLCylinder is creates sphere mesh based on its SLRevolver methods
+/**
+ * @brief SLCylinder is creates sphere mesh based on its SLRevolver methods
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLCylinder : public SLRevolver
 {
 public:
diff --git a/modules/sl/source/mesh/SLDisk.h b/modules/sl/source/mesh/SLDisk.h
index 55949a40..f5f18316 100644
--- a/modules/sl/source/mesh/SLDisk.h
+++ b/modules/sl/source/mesh/SLDisk.h
@@ -13,7 +13,16 @@
 #include <SLRevolver.h>
 
 //-----------------------------------------------------------------------------
-//! SLDisk creates a disk mesh based on SLRevolver
+/**
+ * @brief SLDisk creates a disk mesh based on SLRevolver
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLDisk : public SLRevolver
 {
 public:
diff --git a/modules/sl/source/mesh/SLGrid.h b/modules/sl/source/mesh/SLGrid.h
index 9298c0fa..fd6cbc1f 100644
--- a/modules/sl/source/mesh/SLGrid.h
+++ b/modules/sl/source/mesh/SLGrid.h
@@ -13,10 +13,18 @@
 #include <SLMesh.h>
 
 //-----------------------------------------------------------------------------
-//! SLGrid creates a rectangular grid with lines with a certain resolution
-/*! The SLGrid mesh draws a grid between a minimal and a maximal corner in the
-XZ-plane.
-*/
+/**
+ * @brief SLGrid creates a rectangular grid with lines with a certain resolution
+ * @details The SLGrid mesh draws a grid between a minimal and a maximal corner 
+ * in the XZ-plane.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLGrid : public SLMesh
 {
 public:
diff --git a/modules/sl/source/mesh/SLMesh.cpp b/modules/sl/source/mesh/SLMesh.cpp
index 1541dad7..9897b4cd 100644
--- a/modules/sl/source/mesh/SLMesh.cpp
+++ b/modules/sl/source/mesh/SLMesh.cpp
@@ -33,15 +33,20 @@ using std::set;
 #endif
 
 //-----------------------------------------------------------------------------
-/*!
- * Constructor for mesh objects.
- * Meshes can be used in multiple nodes (SLNode). Meshes can belong
+/**
+ * @brief Construct a new SLMesh::SLMesh object
+ * @details Meshes can be used in multiple nodes (SLNode). Meshes can belong
  * therefore to the global assets such as meshes (SLMesh), materials
- * (SLMaterial), textures (SLGLTexture) and shader programs (SLGLProgram).
- * \param assetMgr Pointer to a global asset manager. If passed the asset
+ * (SLMaterial), textures (SLGLTexture) and shader programs (SLGLProgram).\n
+ * It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param assetMgr Pointer to a global asset manager. If passed the asset
  * manager is the owner of the instance and will do the deallocation. If a
  * nullptr is passed the creator is responsible for the deallocation.
- * \param name Name of the mesh
+ * @param name Name of the mesh
  */
 SLMesh::SLMesh(SLAssetManager* assetMgr, const SLstring& name) : SLObject(name)
 {
diff --git a/modules/sl/source/mesh/SLMesh.h b/modules/sl/source/mesh/SLMesh.h
index 1a48a4aa..f86b8932 100644
--- a/modules/sl/source/mesh/SLMesh.h
+++ b/modules/sl/source/mesh/SLMesh.h
@@ -29,95 +29,103 @@ class SLGLProgram;
 class SLAssetManager;
 
 //-----------------------------------------------------------------------------
-//! An SLMesh object is a triangulated mesh that is drawn with one draw call.
-/*!
-The SLMesh class represents a single mesh object. The mesh object is drawn
-with one draw call using the vertex indices in I16 or I32. A mesh can be drawn
-with triangles, lines or points.
-The vertex attributes are stored in vectors with equal number of elements:
-\n P (vertex position, mandatory)
-\n N (vertex normals)
-\n C (vertex color)
-\n UV[0] (1st. vertex texture coordinates) optional
-\n UV[1] (2nd. vertex texture coordinates) optional
-\n T (vertex tangents) optional
-\n Ji (vertex joint index) optional 2D vector
-\n Jw (vertex joint weights) optional 2D vector
-\n I16 holds the unsigned short vertex indices.
-\n I32 holds the unsigned int vertex indices.
-\n
-The normals of a vertex are automatically calculated in the method calcNormals()
-by averaging the face normals of the adjacent triangles. A vertex has always
-only <b>one</b> normal and is used for the lighting calculation in the shader
-programs. With such averaged normals you can created a interpolated shading on
-smooth surfaces such as a sphere.
-\n
-For objects with sharp edges such as a box you need 4 vertices per box face.
-All normals of a face point to the same direction. This means, that you have
-three times the same vertex position but with different normals for one corner
-of the box.
-\n
-The following image shows a box with sharp edges and a sphere with mostly
-smooth but also 4 sharp edges. The smooth red normal as the top vertex got
-averaged because its position is only once in the vector P. On the other hand
-are the vertices of the hard edges in the front of the sphere doubled.
-\n
-@image html images/sharpAndSmoothEdges.png
-\n
-\n The following the example creates the box with 24 vertices:
-\n The vertex positions and normals in P and N:
-\n P.size = 24
-\n P[0] = [1,1,1]   N[0] = [1,0,0]
-\n P[1] = [1,0,1]   N[1] = [1,0,0]
-\n P[2] = [1,0,0]   N[2] = [1,0,0]
-\n P[3] = [1,1,0]   N[3] = [1,0,0]
-\n
-\n P[4] = [1,1,0]   N[4] = [0,0,-1]
-\n P[5] = [1,0,0]   N[5] = [0,0,-1]
-\n P[6] = [0,0,0]   N[6] = [0,0,-1]
-\n P[7] = [0,1,0]   N[7] = [0,0,-1]
-\n
-\n P[8] = [0,0,1]   N[8] = [-1,0,0]
-\n P[9] = [0,1,1]   N[9] = [-1,0,0]
-\n P[10]= [0,1,0]   N[10]= [-1,0,0]
-\n P[11]= [0,0,0]   N[11]= [-1,0,0]
-\n
-\n P[12]= [1,1,1]   N[12]= [0,0,1]
-\n P[13]= [0,1,1]   N[13]= [0,0,1]
-\n P[14]= [0,0,1]   N[14]= [0,0,1]
-\n P[15]= [1,0,1]   N[15]= [0,0,1]
-\n
-\n P[16]= [1,1,1]   N[16]= [0,1,0]
-\n P[17]= [1,1,0]   N[17]= [0,1,0]
-\n P[18]= [0,1,0]   N[18]= [0,1,0]
-\n P[19]= [0,1,1]   N[19]= [0,1,0]
-\n
-\n P[20]= [0,0,0]   N[20]= [0,-1,0]
-\n P[21]= [1,0,0]   N[21]= [0,-1,0]
-\n P[22]= [1,0,1]   N[22]= [0,-1,0]
-\n P[23]= [0,0,1]   N[23]= [0,-1,0]
-\n
-\n The vertex indices in I16:
-\n I16[] = {0,1,2, 0,2,3,
-\n          4,5,6, 4,6,7,
-\n          8,9,10, 8,10,11,
-\n          12,13,14, 12,14,15,
-\n          16,17,18, 16,18,19,
-\n          20,21,22, 20,22,23}
-\n
-@image html images/boxVertices.png
-\n
-All vertex attributes are added to the vertex array object _vao (SLVertexArray).<br>
-All arrays remain in the main memory for ray tracing.
-A mesh uses only one material referenced by the SLMesh::mat pointer.
-\n
-If a mesh is associated with a skeleton all its vertices and normals are
-transformed every frame by the joint weights. Every vertex of a mesh has
-weights for 1-n joints by which it can be influenced. This transform is
-called skinning and is done in CPU in the method transformSkin. The final
-transformed vertices and normals are stored in _finalP and _finalN.
-*/
-
+/**
+ * @brief An SLMesh object is a triangulated mesh, drawn with one draw call.
+ * @details The SLMesh class represents a single mesh object. The mesh object 
+ * is drawn with one draw call using the vertex indices in I16 or I32. A mesh 
+ * can be drawn with triangles, lines or points.
+ * The vertex attributes are stored in vectors with equal number of elements:
+ * \n P (vertex position, mandatory)
+ * \n N (vertex normals)
+ * \n C (vertex color)
+ * \n UV[0] (1st. vertex texture coordinates) optional
+ * \n UV[1] (2nd. vertex texture coordinates) optional
+ * \n T (vertex tangents) optional
+ * \n Ji (vertex joint index) optional 2D vector
+ * \n Jw (vertex joint weights) optional 2D vector
+ * \n I16 holds the unsigned short vertex indices.
+ * \n I32 holds the unsigned int vertex indices.
+ * \n
+ * The normals of a vertex are automatically calculated in the method calcNormals()
+ * by averaging the face normals of the adjacent triangles. A vertex has always
+ * only <b>one</b> normal and is used for the lighting calculation in the shader
+ * programs. With such averaged normals you can created a interpolated shading on
+ * smooth surfaces such as a sphere.
+ * \n
+ * For objects with sharp edges such as a box you need 4 vertices per box face.
+ * All normals of a face point to the same direction. This means, that you have
+ * three times the same vertex position but with different normals for one corner
+ * of the box.
+ * \n
+ * The following image shows a box with sharp edges and a sphere with mostly
+ * smooth but also 4 sharp edges. The smooth red normal as the top vertex got
+ * averaged because its position is only once in the vector P. On the other hand
+ * are the vertices of the hard edges in the front of the sphere doubled.
+ * \n
+ * @image html images/sharpAndSmoothEdges.png
+ * \n
+ * \n The following the example creates the box with 24 vertices:
+ * \n The vertex positions and normals in P and N:
+ * \n P.size = 24
+ * \n P[0] = [1,1,1]   N[0] = [1,0,0]
+ * \n P[1] = [1,0,1]   N[1] = [1,0,0]
+ * \n P[2] = [1,0,0]   N[2] = [1,0,0]
+ * \n P[3] = [1,1,0]   N[3] = [1,0,0]
+ * \n
+ * \n P[4] = [1,1,0]   N[4] = [0,0,-1]
+ * \n P[5] = [1,0,0]   N[5] = [0,0,-1]
+ * \n P[6] = [0,0,0]   N[6] = [0,0,-1]
+ * \n P[7] = [0,1,0]   N[7] = [0,0,-1]
+ * \n
+ * \n P[8] = [0,0,1]   N[8] = [-1,0,0]
+ * \n P[9] = [0,1,1]   N[9] = [-1,0,0]
+ * \n P[10]= [0,1,0]   N[10]= [-1,0,0]
+ * \n P[11]= [0,0,0]   N[11]= [-1,0,0]
+ * \n
+ * \n P[12]= [1,1,1]   N[12]= [0,0,1]
+ * \n P[13]= [0,1,1]   N[13]= [0,0,1]
+ * \n P[14]= [0,0,1]   N[14]= [0,0,1]
+ * \n P[15]= [1,0,1]   N[15]= [0,0,1]
+ * \n
+ * \n P[16]= [1,1,1]   N[16]= [0,1,0]
+ * \n P[17]= [1,1,0]   N[17]= [0,1,0]
+ * \n P[18]= [0,1,0]   N[18]= [0,1,0]
+ * \n P[19]= [0,1,1]   N[19]= [0,1,0]
+ * \n
+ * \n P[20]= [0,0,0]   N[20]= [0,-1,0]
+ * \n P[21]= [1,0,0]   N[21]= [0,-1,0]
+ * \n P[22]= [1,0,1]   N[22]= [0,-1,0]
+ * \n P[23]= [0,0,1]   N[23]= [0,-1,0]
+ * \n
+ * \n The vertex indices in I16:
+ * \n I16[] = {0,1,2, 0,2,3,
+ * \n          4,5,6, 4,6,7,
+ * \n          8,9,10, 8,10,11,
+ * \n          12,13,14, 12,14,15,
+ * \n          16,17,18, 16,18,19,
+ * \n          20,21,22, 20,22,23}
+ * \n
+ * @image html images/boxVertices.png
+ * \n
+ * All vertex attributes are added to the vertex array object _vao (SLVertexArray).
+ * \n
+ * All arrays remain in the main memory for ray tracing.
+ * A mesh uses only one material referenced by the SLMesh::mat pointer.
+ * \n\n
+ * If a mesh is associated with a skeleton all its vertices and normals are
+ * transformed every frame by the joint weights. Every vertex of a mesh has
+ * weights for 1-n joints by which it can be influenced. This transform is
+ * called skinning and is done in CPU in the method transformSkin. The final
+ * transformed vertices and normals are stored in _finalP and _finalN.
+ * \n
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLMesh : public SLObject
 #ifdef SL_HAS_OPTIX
   , public SLOptixAccelStruct
diff --git a/modules/sl/source/mesh/SLParticleSystem.h b/modules/sl/source/mesh/SLParticleSystem.h
index 55a4eeb3..96384cb9 100644
--- a/modules/sl/source/mesh/SLParticleSystem.h
+++ b/modules/sl/source/mesh/SLParticleSystem.h
@@ -17,8 +17,9 @@
 #include <SLTexColorLUT.h>
 
 //-----------------------------------------------------------------------------
-//! SLParticleSystem creates a particle meshes from a point primitive buffer.
-/*! The SLParticleSystem mesh object of which the vertices are drawn as points.
+/**
+ * @brief SLParticleSystem creates a particle meshes from a point primitive buffer.
+ * @details The SLParticleSystem mesh object of which the vertices are drawn as points.
  * An OpenGL transform feedback buffer is used to update the particle positions
  * on the GPU and a geometry shader is used the create two triangles per
  * particle vertex and orient them as a billboard to the viewer. Geometry
@@ -31,6 +32,13 @@
  * do* methods. All options can also be modified in the UI when the mesh is
  * selected. See the different demo scenes in the app_demo_slproject under the
  * demo scene group Particle Systems.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
  */
 class SLParticleSystem : public SLMesh
 {
diff --git a/modules/sl/source/mesh/SLPoints.h b/modules/sl/source/mesh/SLPoints.h
index 97b258a8..b67c3224 100644
--- a/modules/sl/source/mesh/SLPoints.h
+++ b/modules/sl/source/mesh/SLPoints.h
@@ -14,8 +14,15 @@
 #include <SLRnd3f.h>
 
 //-----------------------------------------------------------------------------
-//! SLPoints creates
-/*! The SLPoints mesh object of witch the vertices are drawn as points.
+/**
+ * @brief The SLPoints mesh object of witch the vertices are drawn as points.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
  */
 class SLPoints : public SLMesh
 {
diff --git a/modules/sl/source/mesh/SLPolygon.h b/modules/sl/source/mesh/SLPolygon.h
index 503ecdbf..efa4281a 100644
--- a/modules/sl/source/mesh/SLPolygon.h
+++ b/modules/sl/source/mesh/SLPolygon.h
@@ -13,11 +13,18 @@
 #include <SLMesh.h>
 
 //-----------------------------------------------------------------------------
-//! SLPolygon creates a convex polyon mesh
-/*!
-The SLPolygon node draws a convex polygon with. The normale vector is
-calculated from the first 3 vertices.
-*/
+/**
+ * @brief SLPolygon creates a convex polyon mesh
+ * @details The SLPolygon node draws a convex polygon with. The normale vector 
+ * is calculated from the first 3 vertices.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLPolygon : public SLMesh
 {
 public:
diff --git a/modules/sl/source/mesh/SLRectangle.h b/modules/sl/source/mesh/SLRectangle.h
index ae28c5f0..d918b091 100644
--- a/modules/sl/source/mesh/SLRectangle.h
+++ b/modules/sl/source/mesh/SLRectangle.h
@@ -13,11 +13,18 @@
 #include <SLMesh.h>
 
 //-----------------------------------------------------------------------------
-//! SLRectangle creates a rectangular mesh with a certain resolution
-/*!
-The SLRectangle node draws a rectangle with a minimal and a maximal corner in
-the x-y-plane. The normal is [0,0,1].
-*/
+/**
+ * @brief SLRectangle creates a rectangular mesh with a certain resolution
+ * @details The SLRectangle node draws a rectangle with a minimal and a maximal 
+ * corner in the x-y-plane. The normal is [0,0,1].
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLRectangle : public SLMesh
 {
 public:
diff --git a/modules/sl/source/mesh/SLRevolver.h b/modules/sl/source/mesh/SLRevolver.h
index 7e1ac5c4..2d291b22 100644
--- a/modules/sl/source/mesh/SLRevolver.h
+++ b/modules/sl/source/mesh/SLRevolver.h
@@ -17,16 +17,23 @@
 class SLAssetManager;
 
 //-----------------------------------------------------------------------------
-//! SLRevolver is an SLMesh object built out of revolving points.
-/*!
- SLRevolver is an SLMesh object that is built out of points that are revolved
- in slices around and axis. The surface will be outwards if the points in the
- array _revPoints increase towards the axis direction.
- If all points in the array _revPoints are different the normals will be
- smoothed. If two consecutive points are identical the normals will define a
- hard edge. Texture coords. are cylindrically mapped.
- See the online example \subpage example-revolver with various revolver objects.
-*/
+/**
+ * @brief SLRevolver is an SLMesh object built out of revolving points.
+ * @details SLRevolver is an SLMesh object that is built out of points that 
+ * are revolved in slices around and axis. The surface will be outwards if the 
+ * points in the array _revPoints increase towards the axis direction. If all 
+ * points in the array _revPoints are different the normals will be smoothed. 
+ * If two consecutive points are identical the normals will define a hard edge. 
+ * Texture coords. are cylindrically mapped. See the online example 
+ * \subpage example-revolver with various revolver objects.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLRevolver : public SLMesh
 {
 public:
diff --git a/modules/sl/source/mesh/SLSphere.h b/modules/sl/source/mesh/SLSphere.h
index 1122cffc..9140b825 100644
--- a/modules/sl/source/mesh/SLSphere.h
+++ b/modules/sl/source/mesh/SLSphere.h
@@ -19,7 +19,16 @@ class SLMaterial;
 class SLAssetManager;
 
 //-----------------------------------------------------------------------------
-//! SLSphere creates a sphere mesh based on SLSpheric w. 180 deg polar angle.
+/**
+ * @brief SLSphere creates a sphere mesh based on SLSpheric w. 180 deg polar angle.
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLSphere : public SLSpheric
 {
 public:
diff --git a/modules/sl/source/mesh/SLSpheric.h b/modules/sl/source/mesh/SLSpheric.h
index 0f6cf805..0f16aef0 100644
--- a/modules/sl/source/mesh/SLSpheric.h
+++ b/modules/sl/source/mesh/SLSpheric.h
@@ -38,4 +38,4 @@ class SLSpheric : public SLRevolver
     SLfloat _thetaEndDEG;   //!< Polar end angle 1-180deg
 };
 //-----------------------------------------------------------------------------
-#endif // SLSPHERE_H
+#endif // SLSPHERIC_H
diff --git a/modules/sl/source/mesh/SLTriangle.h b/modules/sl/source/mesh/SLTriangle.h
index ea3e142f..5b5a13ce 100644
--- a/modules/sl/source/mesh/SLTriangle.h
+++ b/modules/sl/source/mesh/SLTriangle.h
@@ -13,7 +13,16 @@
 #include <SLMesh.h>
 
 //-----------------------------------------------------------------------------
-//! A triangle class as the most simplest mesh
+/**
+ * @brief A triangle class as the most simplest mesh
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP,
+ * _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.
+ */
 class SLTriangle : public SLMesh
 {
 public:
diff --git a/modules/sl/source/node/SLCamera.cpp b/modules/sl/source/node/SLCamera.cpp
index 80c45db2..6ad4325b 100644
--- a/modules/sl/source/node/SLCamera.cpp
+++ b/modules/sl/source/node/SLCamera.cpp
@@ -21,6 +21,17 @@ SLProjType SLCamera::currentProjection  = P_monoPerspective;
 SLfloat    SLCamera::currentFOV         = 45.0f;
 SLint      SLCamera::currentDevRotation = 0;
 //-----------------------------------------------------------------------------
+/**
+ * @brief Construct a new SLCamera::SLCamera object
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within a SLScene::assemble function. All objects that get rendered 
+ * have to do their OpenGL initialization when they are used the first time 
+ * during rendering in the main thread.
+ * @param name Name of the camera
+ * @param textureOnlyProgramId Shader program ID for the textureOnly shader used for background rendering
+ * @param colorAttributeProgramId Shader program ID for the color attribute shader used for background rendering
+ */
 SLCamera::SLCamera(const SLstring& name,
                    SLStdShaderProg textureOnlyProgramId,
                    SLStdShaderProg colorAttributeProgramId)
diff --git a/modules/sl/source/node/SLHorizonNode.cpp b/modules/sl/source/node/SLHorizonNode.cpp
index 9385b4b2..9a1fc812 100644
--- a/modules/sl/source/node/SLHorizonNode.cpp
+++ b/modules/sl/source/node/SLHorizonNode.cpp
@@ -13,6 +13,20 @@
 #include <cmath>
 
 //-----------------------------------------------------------------------------
+/**
+ * @brief Construct a new SLHorizonNode::SLHorizonNode object
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param name Name of the node
+ * @param devRot Device rotation object
+ * @param font Font for the text label
+ * @param shaderDir Path to the shader directory
+ * @param scrW Width of the screen in pixels
+ * @param scrH Height of the sceen in pixels
+ */
 SLHorizonNode::SLHorizonNode(SLstring          name,
                              SLDeviceRotation* devRot,
                              SLTexFont*        font,
diff --git a/modules/sl/source/node/SLLight.cpp b/modules/sl/source/node/SLLight.cpp
index aacff49c..27d86c9f 100644
--- a/modules/sl/source/node/SLLight.cpp
+++ b/modules/sl/source/node/SLLight.cpp
@@ -15,6 +15,18 @@ SLCol4f SLLight::globalAmbient    = SLCol4f(0.1f, 0.1f, 0.1f, 1.0f);
 SLfloat SLLight::gamma            = 1.0f;
 SLbool  SLLight::doColoredShadows = false;
 //-----------------------------------------------------------------------------
+/**
+ * @brief Construct a new SLLight::SLLight object
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param ambiPower Ambient light power
+ * @param diffPower Diffuse light power
+ * @param specPower Specular light power
+ * @param id Light ID
+ */
 SLLight::SLLight(SLfloat ambiPower,
                  SLfloat diffPower,
                  SLfloat specPower,
diff --git a/modules/sl/source/node/SLLightDirect.cpp b/modules/sl/source/node/SLLightDirect.cpp
index 5d8ae0b5..7f9ea009 100644
--- a/modules/sl/source/node/SLLightDirect.cpp
+++ b/modules/sl/source/node/SLLightDirect.cpp
@@ -17,6 +17,19 @@
 #include <SLSpheric.h>
 
 //-----------------------------------------------------------------------------
+/**
+ * @brief Construct a new SLLightDirect::SLLightDirect object
+ * @details It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within a SLScene::assemble function. All objects that get rendered 
+ * have to do their OpenGL initialization when they are used the first time 
+ * during rendering in the main thread.
+ * @param assetMgr AssetManager that will own the light mesh
+ * @param s SLScene pointer
+ * @param arrowLength Length of the arrow visualization mesh
+ * @param hasMesh Boolean if a mesh should be created and shown
+ * @param doCascadedShadows Boolean for doing cascaded shadow mapping
+ */
 SLLightDirect::SLLightDirect(SLAssetManager* assetMgr,
                              SLScene*        s,
                              SLfloat         arrowLength,
@@ -51,6 +64,25 @@ SLLightDirect::SLLightDirect(SLAssetManager* assetMgr,
     init(s);
 }
 //-----------------------------------------------------------------------------
+/**
+ * @brief Construct a new SLLightDirect::SLLightDirect object
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param assetMgr AssetManager that will own the light mesh
+ * @param s SLScene pointer
+ * @param posx Light position x
+ * @param posy Light position y
+ * @param posz Light position z
+ * @param arrowLength Length of the arrow visualization mesh
+ * @param ambiPower Ambient light power
+ * @param diffPower Diffuse light power
+ * @param specPower Specular light power
+ * @param hasMesh Boolean if a mesh should be created and shown
+ * @param doCascadedShadows Boolean for doing cascaded shadow mapping
+ */
 SLLightDirect::SLLightDirect(SLAssetManager* assetMgr,
                              SLScene*        s,
                              SLfloat         posx,
diff --git a/modules/sl/source/node/SLLightRect.cpp b/modules/sl/source/node/SLLightRect.cpp
index b6b1f1e2..2630e9bb 100644
--- a/modules/sl/source/node/SLLightRect.cpp
+++ b/modules/sl/source/node/SLLightRect.cpp
@@ -18,6 +18,19 @@
 extern SLfloat rnd01();
 
 //-----------------------------------------------------------------------------
+/**
+ * @brief Construct a new SLLightRect::SLLightRect object
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param assetMgr AssetManager that will own the light mesh
+ * @param s SLScene pointer
+ * @param w Width of the light rectangle
+ * @param h Height if the light rectangle
+ * @param hasMesh Boolean if a mesh should be created and shown
+ */
 SLLightRect::SLLightRect(SLAssetManager* assetMgr,
                          SLScene*        s,
                          SLfloat         w,
diff --git a/modules/sl/source/node/SLLightSpot.cpp b/modules/sl/source/node/SLLightSpot.cpp
index 49477eb8..39356789 100644
--- a/modules/sl/source/node/SLLightSpot.cpp
+++ b/modules/sl/source/node/SLLightSpot.cpp
@@ -17,6 +17,19 @@
 #include <SLSpheric.h>
 
 //-----------------------------------------------------------------------------
+/**
+ * @brief Construct a new SLLightSpot::SLLightSpot object
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param assetMgr AssetManager that will own the light mesh
+ * @param s SLScene pointer
+ * @param radius Radius of the spot light sphere
+ * @param spotAngleDEG Spot cone shine angle in degrees
+ * @param hasMesh Boolean if a mesh should be created and shown
+ */
 SLLightSpot::SLLightSpot(SLAssetManager* assetMgr,
                          SLScene*        s,
                          SLfloat         radius,
diff --git a/modules/sl/source/node/SLNode.cpp b/modules/sl/source/node/SLNode.cpp
index eafc471e..37c4e92f 100644
--- a/modules/sl/source/node/SLNode.cpp
+++ b/modules/sl/source/node/SLNode.cpp
@@ -28,9 +28,15 @@ unsigned int SLNode::instanceIndex = 0;
 // Static updateRec counter
 SLuint SLNode::numWMUpdates = 0;
 //-----------------------------------------------------------------------------
-/*!
-Default constructor just setting the name.
-*/
+/**
+ * @brief Construct a new SLNode::SLNode object
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param name Name of the node
+ */
 SLNode::SLNode(const SLstring& name) : SLObject(name)
 {
     _parent   = nullptr;
@@ -53,6 +59,11 @@ SLNode::SLNode(const SLstring& name) : SLObject(name)
 //-----------------------------------------------------------------------------
 /*!
 Constructor with a mesh pointer and name.
+It is important that during instantiation NO OpenGL functions (gl*) get called
+because this constructor will be most probably called in a parallel thread from
+within a SLScene::assemble function. All objects that get rendered have to do 
+their OpenGL initialization when they are used the first time during rendering 
+in the main thread.
 */
 SLNode::SLNode(SLMesh* mesh, const SLstring& name) : SLObject(name)
 {
@@ -80,6 +91,11 @@ SLNode::SLNode(SLMesh* mesh, const SLstring& name) : SLObject(name)
 //-----------------------------------------------------------------------------
 /*!
 Constructor with a mesh pointer, translation vector and name.
+It is important that during instantiation NO OpenGL functions (gl*) get called
+because this constructor will be most probably called in a parallel thread from
+within a SLScene::assemble function. All objects that get rendered have to do 
+their OpenGL initialization when they are used the first time during rendering 
+in the main thread.
 */
 SLNode::SLNode(SLMesh*         mesh,
                const SLVec3f&  translation,
diff --git a/modules/sl/source/node/SLNode.h b/modules/sl/source/node/SLNode.h
index c8f0e3a3..a2161342 100644
--- a/modules/sl/source/node/SLNode.h
+++ b/modules/sl/source/node/SLNode.h
@@ -93,21 +93,21 @@ struct SLNodeStats
 };
 //-----------------------------------------------------------------------------
 //! SLNode represents a node in a hierarchical scene graph.
-/*!
- * SLNode is the most important building block of the scene graph.
+/** 
+ * @details This is the most important building block of the scene graph.
  * A node can have 0-N children nodes in the vector _children. With child
  * nodes you can build hierarchical structures. A node without a mesh can act
  * as parent node to group its children. A node without children only makes
  * sense to hold a mesh for visualization. The pointer _parent points to the
- * parent of a child node. \n\n
- *
+ * parent of a child node.
+ * \n\n
  * A node can point to a single SLMesh object for the rendering of triangles
  * lines or points meshes. Meshes are stored in the SLAssetManager::_meshes
  * vector. Multiple nodes can point to the same mesh object. The node is
  * therefore not the owner of the meshes and does not delete them. The mesh
  * is drawn by the methods SLNode::drawMesh and alternatively by
- * SLNode::drawRec.\n\n
- *
+ * SLNode::drawRec.
+ * \n\n
  * A node can be transformed and has therefore a object matrix (_om) for its
  * local transform. All other matrices such as the world matrix (_wm), the
  * inverse world matrix (_wmI) are derived from the object matrix and
@@ -132,6 +132,11 @@ struct SLNodeStats
  * and SLLightRect are derived from SLNode and represent light sources in the
  * scene. Cameras and lights can be placed in the scene because of their
  * inheritance of SLNode.\n
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
  */
 class SLNode
   : public SLObject
diff --git a/modules/sl/source/node/SLNodeLOD.cpp b/modules/sl/source/node/SLNodeLOD.cpp
index dd87d97a..c4e1f560 100644
--- a/modules/sl/source/node/SLNodeLOD.cpp
+++ b/modules/sl/source/node/SLNodeLOD.cpp
@@ -18,7 +18,12 @@
  * < than the minLodCoverage of the last node in the LOD group. If the first
  * child node has e.g. a minLodCoverage of 0.1 it means that it will be visible
  * if its bounding rectangle covers more then 10% of the viewport. The first
- * child node in the group must be the one with the highest resolution.
+ * child node in the group must be the one with the highest resolution.\n
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
  * \param childToAdd LOD child node pointer to add
  * \param minLodCoverage A value > 0 and < 1 and < than the minLodCoverage
  * of the last node in the LOD group
diff --git a/modules/sl/source/node/SLSkybox.cpp b/modules/sl/source/node/SLSkybox.cpp
index fc7ce460..5f36b46b 100644
--- a/modules/sl/source/node/SLSkybox.cpp
+++ b/modules/sl/source/node/SLSkybox.cpp
@@ -17,10 +17,23 @@
 #include <SLSkybox.h>
 
 //-----------------------------------------------------------------------------
-//! Cubemap constructor with cubemap images
-/*! All resources allocated are stored in the SLScene vectors for textures,
-materials, programs and meshes and get deleted at scene destruction.
-*/
+/**
+ * @brief Construct a new SLSkybox::SLSkybox object with 6 images for all sides
+ * @details It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within a SLScene::assemble function. All objects that get rendered 
+ * have to do their OpenGL initialization when they are used the first time 
+ * during rendering in the main thread.
+ * @param assetMgr Asset manager that will own the skybox mesh
+ * @param shaderPath Path to the shader files
+ * @param cubeMapXPos Texture image file for the positive X side
+ * @param cubeMapXNeg Texture image file for the negative X side
+ * @param cubeMapYPos Texture image file for the positive Y side
+ * @param cubeMapYNeg Texture image file for the negative Y side
+ * @param cubeMapZPos Texture image file for the positive Z side 
+ * @param cubeMapZNeg Texture image file for the negative Z side
+ * @param name Name of the skybox
+ */
 SLSkybox::SLSkybox(SLAssetManager* assetMgr,
                    SLstring        shaderPath,
                    SLstring        cubeMapXPos,
@@ -80,6 +93,23 @@ SLSkybox::SLSkybox(SLAssetManager* assetMgr,
 all the textures needed for image based lighting and store them in the textures
 of the material of this sky box.
 */
+
+/**
+ * @brief Construct a new SLSkybox::SLSkybox object with an HDR image
+ * @details This constructor generates a cube map skybox from a HDR Image and also
+ * all the textures needed for image based lighting and store them in the textures
+ * of the material of this sky box.\n
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param assetMgr Asset manager that will own the skybox mesh
+ * @param shaderPath Path to the shader files
+ * @param hdrImage HDR texture image file
+ * @param resolution Resolution of the texture objects for image based lighting
+ * @param name Name of the skybox
+ */
 SLSkybox::SLSkybox(SLAssetManager* am,
                    SLstring        shaderPath,
                    SLstring        hdrImage,
diff --git a/modules/sl/source/node/SLText.cpp b/modules/sl/source/node/SLText.cpp
index 3f0145da..503f2393 100644
--- a/modules/sl/source/node/SLText.cpp
+++ b/modules/sl/source/node/SLText.cpp
@@ -12,9 +12,19 @@
 #include <SLText.h>
 
 //-----------------------------------------------------------------------------
-/*!
-The ctor sets all members and translates to the min. position.
-*/
+/**
+ * @brief Construct a new SLText::SLText object
+ * @remarks It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param text Text to be rendered
+ * @param font SLTexTont to be used
+ * @param color Color for font
+ * @param maxWidth Max. line width in pixels
+ * @param lineHeightFactor Line hight factor >= 1.0
+ */
 SLText::SLText(SLstring   text,
                SLTexFont* font,
                SLCol4f    color,
diff --git a/modules/sl/source/node/SLTransformNode.cpp b/modules/sl/source/node/SLTransformNode.cpp
index 87c14f8b..efecba9b 100644
--- a/modules/sl/source/node/SLTransformNode.cpp
+++ b/modules/sl/source/node/SLTransformNode.cpp
@@ -16,14 +16,16 @@
 #include <SLDisk.h>
 
 //-----------------------------------------------------------------------------
-/*!
- Constructor for a transform node.
- Because a transform node will be added and removed on the fly to the
- scenegraph it well be the owner of its meshes (SLMesh), materials (SLMaterial)
- and shader programs (SLGLProgram). It has to delete them in the destructor.
- @param sv Pointer to the SLSceneView
- @param targetNode Pointer to the node that should be transformed.
- @param shaderDir Path to the shader files
+/**
+ * @brief Construct a new SLTransformNode::SLTransformNode object * 
+ * @details It is important that during instantiation NO OpenGL functions (gl*) 
+ * get called because this constructor will be most probably called in a parallel 
+ * thread from within an SLScene::registerAssetsToLoad or SLScene::assemble 
+ * function. All objects that get rendered have to do their OpenGL initialization 
+ * when they are used the first time during rendering in the main thread.
+ * @param sv Pointer to the SLSceneView
+ * @param targetNode Pointer to the node that should be transformed.
+ * @param shaderDir Path to the shader files
  */
 SLTransformNode::SLTransformNode(SLSceneView* sv,
                                  SLNode*      targetNode,