anchor.diff:  
   Ultimately all jME projects should use the `.j3o` format for storing assets. However during development a format is required to export scenes from Blender in a format suitable for conversion (either through the SDK or directly through code).
   
  -Use of glTF (or another standard format) has a significant advantage of direct import of `.blend` files: new versions of Blender with significant enhancements are released fairly regularly. Using a standard format allows new features to be used without requiring updates to the Blender importer.
  +Use of glTF (or another standard format) has a significant advantage over direct import of `.blend` files: new versions of Blender with significant enhancements are released fairly regularly. Using a standard format allows new features to be used without requiring updates to the Blender importer.
   
   [NOTE]
   Blender 2.7 had a number of problems in exporting glTF; these notes refer exclusively to Blender 2.8+
  
positive.code: == Animations
  
  . Blender supports non-linear transitions using F-Curves. However the glTF importer only supports linear transitions. There are 2 ways to ensure all transitions are linear:
  .. In the graph editor, select all transitions and convert them to linear
  .. At export time, force sampling using `export_force_sampling=True`. By default a sample is created from each frame of the animation. This can be changed using `export_frame_step=n` where n is number of frames between samples
  . jME does not support IK constraints. These need to baked into keyframes before export.
  . A (potentially) confusing aspect of the export is that all animation actions will be children of the armature node, not the object node. However the action currently being tweaked will be linked under the object node. If you add the object node after import to the jME scene (e.g. by using `getChild` to find it by name) then the only available animation will be the one that is active when the export occurs. To solve this problem make sure you search for and add the parent armature node.
  
  == Materials
  
  
negative.code: . If an object has a single material, the corresponding node in the imported structure will have type `Geometry` with the object's mesh and the associated material.
  . If an object has more than one material, the corresponding node will have type `Node` with 1 child per material. Each of these children will be a `Geometry` with the associated material and a mesh containing the vertices assigned to the material.
  
  For example, if a blender scene has the following structure
  
  ....
  Scene collection
      Collection A
          Tree (Object)
              Tree_Mesh (Mesh)
          Car (Object)
              Car_Mesh (Mesh)
                  Body (Material)
          House (Object)
              House_Mesh (Mesh)
                  Walls (Material)
                  Roof (Material)
      Collection B
          Person_Armature (Armature)
              Root (Bone)
                  Head (Bone)
              Animations
                  Walk (Action)
                  NLA Tracks
                      NLA Track
                          Run (Action)
              Person (Object)
                  Animation
                      Walk (Action link)
                  Person_Mesh
  ....
  
  Then after export to glTF format and import to jME it will look like:
  
  ....
  Scene (Node)
      Tree (Geometry)
          Default (Material)
      Car (Geometry)
          Body (Material)
      House (Node)
          House_1 (Geometry)
              Walls (Material)
          House_1 (Geometry)
              Roof (Material)
      Person_Armature (Node)
          Animations (Animation Control)
              Walk (Animation)
              Run (Animation)
          Person (Geometry)
              Animations (Animation Control)
                  Walk (Animation)
  ....
  
  For example, the animated person could be loaded with a custom material assigned as follows:
  
  [source,java]
  ----
  ModelKey key = new ModelKey("Models/model.glb");
  Node scene = (Node)assetManager.loadModel(key);
  Node person = scene.getChild("Person_Armature");
  Geometry geometry = (Geometry)person.getChild("Person");
  geometry.setMaterial(customMaterial);
  root.attachChild(person);
  ----
  
  == Additional Reading
  
  Thread announcing glTF support: https://hub.jmonkeyengine.org/t/jme-gltf-support/39174
  
  Documentation for the python export functions https://docs.blender.org/api/current/bpy.ops.export_scene.html
  
  glTF specification https://github.com/KhronosGroup/glTF/tree/master/specification/2.0
  