How to copy SENC from NavBox
To read a SENC from the NavBox use NavBoxRESTClient SDK component and its INavBoxRESTClient interface that described in inc/datalayer/navbox_client/navbox_client_interface.h
To create a NavBoxRESTClient component use SDKCreateComponentInstance of kNavBoxRESTClientCID class id that defined in inc/datalayer/navbox_client/component_ids.h
To get access to the NavBox you need to initialize the component with a several required parameters.
In particular, you have to SetProperty of ISDKProperties interface that implements the NavBoxRESTClient component.

Set kNavBoxRESTClientProperty_Host which must specify a valid host address of the NavBox.
Set kNavBoxRESTClientProperty_SoftwareName which is the application name, its used only for logging logging purpose by the NavBox service but it must be provided.
Set kNavBoxRESTClientProperty_SoftwareVersion which is the application version, its also used only for logging purpose but must be provided.

The next two parameters require a more detailed explanation.
kNavBoxRESTClientProperty_ServerToken, its a string that identifies the NavBox, indicating to the NavBox that the application is aware of the security scheme and knows the NavBox details.
The NavBox token string is placed in the NavStick during synchronization with the NAVTOR back office. It can be found on the NavStick path //INFO/NAVTOR/Setup/NavBox/APICredentials 
Once obtained, the string could be saved in a secure way to a local drive for later use without requesting the NavStick. This can be done during the installation phase of the application.
If for some reason the NavStick is not available and the NavBox token has not been obtained, the only way to get it is by calling NAVTOR support.

kNavBoxRESTClientProperty_OEMToken is a string that released by NAVTOR for an OEM. It has to be passed to the NavBox during the initialization phase.
It is the OEM responsibility to store the OEM token in the its system in a way that prevents unauthorized use.
The NavBox in the system must be aware of the OEM token to recognize and grant the access.
The OEM token is uploaded from the NAVTOR Back Office during initialization for a specific system.

Once you get connected to the NavBox you may start using NavBox services.
Use INavBoxRESTClient interface method GetSENCFiles to get the list of SENC files that need to be copied to a local drive.
Use INavBoxRESTClient interface method GetSENCFileInfo to get complete information for a file from the list.
In the last step, use INavBoxRESTClient interface method OpenSENCFileStream to get the file stream to copy the file content.

How to - Specifics of using OpenGL rendering in SDK.

How to initialize the SDK OpenGL rendering backend.
Create SDK_VISGL_NAMESPACE::kSceneManagerGLCID component and get SDK_VISGL_NAMESPACE::ISceneManagerGL interface.
See inc/visualizationlayer/inc/vismangl/component_ids.h and inc/visualizationlayer/inc/vismangl/scene_manager_gl_interface.h where required constants are defined.
Create initialization parameters using SDK_VISGL_NAMESPACE::CreateSceneManagerGLInitialParameters helper found on inc/visualizationlayer/inc/vismangl/scene_manager_gl_helper.h as follows.
      ISDKParametersSP init_params;
      SDK_VISGL_NAMESPACE::CreateSceneManagerGLInitialParameters(
        L"scene_manager",      // Any name.
        gl_type,               // OpenGL subset or auto detected, see SceneManagerGLType in scene_manager_gl_interface.h for reference.
        context_to_share_with, // Pointer to ISDKParameters that contains a valid platform-specific OpenGL context to share with. It can be nullptr in case if you are not going to or cannot use context sharing.
        ext_created_ctx,       // Pointer to sdk::gl2d::IGL2DExtCreatedGlCtx that contains OpenGL context created by the application. It can be nullptr.
        scene_manager_gl,      // Pointer to ISceneManagerGL which is the previously instantiated OpenGL scene manager instance. It is intended to optimize the use of OpenGL resources, e.g. if the application is not a single view. It can be nullptr.
        sdk::gl2d::kGL2DTextureFormat_RGBA, // Format of the scene texture.
        static_cast<SDKUInt32>(scene_size.width),  // Scene width.
        static_cast<SDKUInt32>(scene_size.height), // Scene height.
        dpm,                                       // Scene resolution in DPM.
        0,                                         // Flags. Reserved, 0 for now.
        init_params); // The output.

Initialize the scene manager with the created parameters. Check if it succeeded.
In case of failure check the returned error code and reports from the error logs located in the ($sdk_program_data)/logging.

Get the scene control SDK_VISGL_NAMESPACE::ISceneControlGLSP scene_control = scene_manager.GetInterface<SDK_VISGL_NAMESPACE::ISceneControlGL>();
Connect scene control to listen events from the scene manager.
      SDK_VISGL_NAMESPACE::ISceneManagerGLCallbackSP callback(
        new SceneManagerEventsListener(this));
      SDKUInt32 scene_listener_cookie = static_cast<SDKUInt32>(-1);
      res = AdviseToConnectionPoint(scene_manager,
        SDK_VISGL_NAMESPACE::ISceneManagerGLCallback::IID(), callback,
        scene_listener_cookie);

Where SceneManagerEventsListener is an implementation of SDK_VISGL_NAMESPACE::ISceneManagerGLCallback.

Below is a list of the recommended settings for the scene manager.

      Enable OpenGL data cache.
      Pros - speeds up data loading when using it not for the first time.
      Cons - occupies local disk space. From KBytes to over 10 MBytes per cell, depending on cell size.
      m_scene_manager->SetProperty(
        kSceneManagerGLProperty_GLDataCache_On,
        ScopedAny(true));
      
      Limit the ammount of memory that the graphic cache is allowed to occupy in the application memory space. In MB.
      The graphics cache is a collection of images of data sets in a form that allows them to be rendered without additional preparation. It's stored in the application memory space.
      m_scene_manager->SetProperty(
        kSceneManagerGLProperty_GraphicCache_MaxAppMemoryMb,
        ScopedAny(1300)); // ~1.3GB, you can define more or less depending on your application preference.


How to add an ENC data source to a scene.

The scene is split into layers. The data source must be bound with the layer. The layer for ENC is predefined and created by the scene manager, its name is "chart".
Use IDataSourcesManager to add ENC data source to scene.
Get the data source manager from the scene manager.
    IDataSourcesManagerSP datasources_manager;
    scene_manager->GetDataSourceManager(datasources_manager);

Add data source to data source manager.
    ISDKParametersSP params(new ParametersVector<ISDKParameters>());
    // Possible values for the flag are kAddDataSourceFlag_None, kAddDataSourceFlag_ChartDatabase, kAddDataSourceFlag_WeatherDatabase and kAddDataSourceFlag_RoutesDatabase.
    // These flags are used to recognize the group in group operations. These flags are not used by the SDK.
    // The flag value can be kAddDataSourceFlag_None if you don't need to recognize the data source by flag, you can also add your own flag.
    params->SetParameter(kDataSourceParameter_Flags, ScopedAny(flags));

    IDataSourceBaseSP datasource;
    datasources_manager->AddDataSource(
      ScopedString(wks_name), // The workspace name
      ScopedAny(wks), // Pointer to IWorkspace of an opened workspace.
      params, // Pointer to the parameters that holds the flags to be assigned to the added data source. 
      datasource);

Get the layer intended for ENC data sources.
    SDK_VISGL_NAMESPACE::ISceneLayerGLSP scene_layer_chart;
    res = scene_layers_manager->FindLayer(ScopedString(L"chart"), scene_layer_chart);
Bind the data source by name.
    scene_layer_chart->BindDataSource(ScopedString(wks_name));

How to add Overview to the scene.
Open Overview workspace.

Add data source to data source manager.

    IDataSourcesManagerSP datasources_manager;
    scene_manager->GetDataSourceManager(datasources_manager);

    ISDKParametersSP params(new ParametersVector<ISDKParameters>());
    params->SetParameter(kDataSourceParameter_Flags, ScopedAny(kAddDataSourceFlag_None));

    IDataSourceBaseSP datasource;
    datasources_manager->AddDataSource(
      ScopedString(overview_wks_name), // The Overview workspace name
      ScopedAny(overview_wks), // Pointer to IWorkspace of Overview workspace.
      params, // Pointer to the parameters that holds the flags to be assigned to the added data source. 
      datasource);

Create a layer for Overview.
        const SDKUInt64 ov_flags =
          kSceneLayerGLFlag_Overview |           // Indicates the Overview layer.
          kSceneLayerGLFlag_PortrayalDependent | // Automatically re-render if portrayal changed.
          kSceneLayerGLFlag_UsePortrayal;        // Use internal portrayal procedures.

        SDK_VISGL_NAMESPACE::ISceneLayerGLSP scene_layer_overview;
        res = scene_layers_manager->AddLayer(
          ScopedString(sdk::gdb::senc::kOverviewGeodatabaseName), // Overview database name defined in //inc/datalayer/inc/senc/senc_exchange_set.h
          kSceneLayerGLType_Default, // Default layer type, there are few specific layer types i.e. kSceneLayerGLType_Radar and kSceneLayerGLType_GroundingCheck.
          kSceneLayerGLPriority_Overview, // Layer priority specifically for the Overview, defined in //inc/visualizationlayer/inc/vismangl/scene_layers_manager_gl_interface.h
          ov_flags, // Scene layer flags.
          ScopedAny(kSceneRenderer_Default), // Currently only one type of scene layer renderer type is defined.
          ISDKParametersSP(), // No additional parameters.
          &scene_layer_overview);

Bind the data source.
          scene_layer_overview->BindDataSource(ScopedString(overview_wks_name));
