Updated all node, mesh and material classes with a remark about not d…

…oing OpenGL calls during instantiation.

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;
 };
 //-----------------------------------------------------------------------------

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:

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:

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:

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:

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:

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;
 };
 //-----------------------------------------------------------------------------

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:

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:

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:

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:

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:

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:

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: