AppCommon Class Reference

Top level class for the major global instances off an SLProject app. More...

#include <AppCommon.h>

Static Public Member Functions
static void	createApp (SLstring appName)
	Application creation function. More...
static void	registerCoreAssetsLoad ()
static void	switchScene (SLSceneView *sv, SLSceneID sceneID)
static void	deleteApp ()
	Calls the destructor of the single scene instance. More...
static void	handleParallelJob ()
	Starts parallel job if one is queued. More...
static void	jobProgressMsg (string msg)
	Thread-safe setter of the progress message. More...
static void	jobProgressNum (int num)
static void	jobProgressMax (int max)
static string	jobProgressMsg ()
	Thread-safe getter of the progress message. More...
static int	jobProgressNum ()
static int	jobProgressMax ()

Static Public Attributes
static SLInputManager	inputManager
	Input events manager. More...
static SLAssetManager *	assetManager = nullptr
	asset manager is the owner of all assets More...
static SLAssetLoader *	assetLoader = nullptr
	Asset-loader for async asset loading. More...
static SLScene *	scene = nullptr
	Pointer to the one and only SLScene instance. More...
static SLVSceneView	sceneViews
	Vector of sceneview pointers. More...
static SLUiInterface *	gui = nullptr
	Pointer to the GUI. More...
static SLDeviceRotation	devRot
	Mobile device rotation from IMU. More...
static SLDeviceLocation	devLoc
	Mobile device location from GPS. More...
static SLstring	name = "SLProjectApp"
	Application name. More...
static SLstring	appTag = "SLProject"
	Tag string used in logging. More...
static SLstring	version = "4.2.001"
	SLProject version string. More...
static SLstring	asciiLabel
	SLProject ascii label string. More...
static SLstring	configuration = "Release"
	Debug or Release configuration. More...
static SLstring	gitBranch = SL_GIT_BRANCH
	Current GIT branch. More...
static SLstring	gitCommit = SL_GIT_COMMIT
	Current GIT commit short hash id. More...
static SLstring	gitDate = SL_GIT_DATE
	Current GIT commit date. More...
static SLstring	exePath
	executable root path More...
static SLstring	configPath
	Default path for calibration files. More...
static SLstring	externalPath
	Default path for external file storage. More...
static SLstring	dataPath
	Path to data directory (it is set platform dependent) More...
static SLstring	shaderPath
	Path to GLSL shader programs. More...
static SLstring	modelPath
	Path to 3D models. More...
static SLstring	texturePath
	Path to texture images. More...
static SLstring	fontPath
	Path to font images. More...
static SLstring	videoPath
	Path to video files. More...
static SLSceneID	sceneID = SL_EMPTY_SCENE_ID
	ID of currently loaded scene. More...
static optional< SLSceneID >	sceneToLoad
	Scene id to load at start up. More...
static map< string, string >	deviceParameter
	Generic device parameter. More...
static deque< function< void(void)> >	jobsToBeThreaded
	Queue of functions to be executed in a thread. More...
static deque< function< void(void)> >	jobsToFollowInMain
	Queue of function to follow in the main thread. More...
static atomic< bool >	jobIsRunning
	True if a parallel job is running. More...
static CVCalibrationEstimatorParams	calibrationEstimatorParams
static CVCalibrationEstimator *	calibrationEstimator = nullptr
static SLstring	calibIniPath
	That's where data/calibrations folder is located. More...
static SLstring	calibFilePath
	That's where calibrations are stored and loaded from. More...
static SLIOBuffer	fontDataProp
static SLIOBuffer	fontDataFixed
static const string	CALIB_FTP_HOST = "pallas.ti.bfh.ch:21"
	ftp host for calibration up and download More...
static const string	CALIB_FTP_USER = "upload"
	ftp login user for calibration up and download More...
static const string	CALIB_FTP_PWD = "FaAdbD3F2a"
	ftp login pwd for calibration up and download More...
static const string	CALIB_FTP_DIR = "calibrations"
	ftp directory for calibration up and download More...
static const string	PROFILE_FTP_DIR = "profiles"
	ftp directory for profiles upload More...

Static Private Member Functions
static void	onDoneLoading (SLSceneView *sv, SLScene *s, SLfloat startLoadMS)
static void	onDoneAssembling (SLSceneView *sv, SLScene *s, SLfloat startLoadMS)

Static Private Attributes
static string	_jobProgressMsg = ""
	Text message to show during progress. More...
static atomic< int >	_jobProgressNum
	Integer value to show progress. More...
static atomic< int >	_jobProgressMax
	Max. integer progress value. More...
static mutex	_jobMutex
	Mutex to protect parallel access. More...

Detailed Description

Top level class for the major global instances off an SLProject app.

The AppCommon holds static instances of top-level items such as the asset manager, the scene pointer, the vector of all sceneviews, the gui pointer, the camera calibration objects and the device rotation and location information.
The static function createApp is called by the C-interface functions slCreateApp and the function deleteApp by slTerminate. At the moment only one scene can be open at the time.
AppCommon holds two static video camera calibrations, one for a main camera (mainCam) and one for the selfie camera on mobile devices (scndCam). The pointer activeCamera points to the active one.

Definition at line 54 of file AppCommon.h.

Member Function Documentation

createApp()

void AppCommon::createApp ( SLstring  appName )

static

Application creation function.

Writes and inits the static application information and create the single instances of SLGLState, SLAssetManager and SLAssetLoader. Gets called by the C-interface function slCreateApp.

See examples usages in:

• 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
  /param applicationName The apps name

Definition at line 111 of file AppCommon.cpp.

{
    assert(AppCommon::scene == nullptr &&
           "You can create only one AppCommon");
 
    // Initialize the global SLGLState instance
    SLGLState::instance()->initAll();
 
    name = std::move(appName);
    SLGLProgramManager::init(dataPath + "shaders/", configPath);
 
    assetManager = new SLAssetManager();
 
    assetLoader = new SLAssetLoader(AppCommon::modelPath,
                                    AppCommon::texturePath,
                                    AppCommon::shaderPath,
                                    AppCommon::fontPath);
 
    GlobalTimer::timerStart();
 
#ifdef SL_HAS_OPTIX
    SLOptix::exePath = AppCommon::exePath;
    SLOptix::createStreamAndContext();
#endif
}

deleteApp()

void AppCommon::deleteApp ( )

static

Calls the destructor of the single scene instance.

Destroys all data by calling the destructor of the single scene instance. All other date gets destroyed from there. This function gets called by the SLProject C-Interface function slTerminate that should be called at the end of any SLProject application.

Definition at line 298 of file AppCommon.cpp.

{
    // The WebGL context is apparently already destroyed when we call this function
#ifndef SL_EMSCRIPTEN
    assert(AppCommon::scene != nullptr &&
           "You can delete a scene only once");
 
    for (auto* sv : sceneViews)
        delete sv;
    sceneViews.clear();
 
    delete scene;
    scene = nullptr;
 
    delete assetManager;
    assetManager = nullptr;
 
    delete assetLoader;
    assetLoader = nullptr;
#endif
 
    if (gui)
    {
        delete gui;
        gui = nullptr;
    }
 
    // Deallocate global font data.
    AppCommon::fontDataProp.deallocate();
    AppCommon::fontDataFixed.deallocate();
 
    // The WebGL context is apparently already destroyed when we call this function
#ifndef SL_EMSCRIPTEN
    // delete default stuff:
    SLGLProgramManager::deletePrograms();
    SLMaterialDefaultGray::deleteInstance();
#endif
 
    // Delete the default materials
    SLMaterialDefaultGray::deleteInstance();
    SLMaterialDefaultColorAttribute::deleteInstance();
 
    // Delete the global SLGLState instance
    SLGLState::deleteInstance();
}

handleParallelJob()

void AppCommon::handleParallelJob ( )

static

Starts parallel job if one is queued.

Parallel executed job can be queued in jobsToBeThreaded. Only functions are allowed that do not call any OpenGL functions. So no scenegraph changes are allowed because they involve mostly OpenGL state and context changes. Only one parallel job is executed at once parallel to the main rendering thread. The function in jobsToFollowInMain will be executed in the main tread after the parallel are finished.
The handleParallelJob function gets called in slUpdateAndPaint before a new frame gets started. See an example parallel job definition in AppDemoGui. If a parallel job is running the jobProgressMsg can be shown during execution. If jobProgressMax is 0 the jobProgressNum value can be shown an number. If jobProgressMax is not 0 the fraction of jobProgressNum/jobProgressMax can be shown within a progress bar. See the example in AppDemoGui::build.

Definition at line 359 of file AppCommon.cpp.

{
    // Execute queued jobs in a parallel thread
    if (!AppCommon::jobIsRunning &&
        !AppCommon::jobsToBeThreaded.empty())
    {
        function<void(void)> job = AppCommon::jobsToBeThreaded.front();
        thread               jobThread(job);
        AppCommon::jobIsRunning = true;
        AppCommon::jobsToBeThreaded.pop_front();
        jobThread.detach();
    }
 
    // Execute the jobs to follow in the this (the main) thread
    if (!AppCommon::jobIsRunning &&
        AppCommon::jobsToBeThreaded.empty() &&
        !AppCommon::jobsToFollowInMain.empty())
    {
        for (const auto& jobToFollow : AppCommon::jobsToFollowInMain)
            jobToFollow();
        AppCommon::jobsToFollowInMain.clear();
    }
}

jobProgressMax() [1/2]

static int AppCommon::jobProgressMax ( )

inlinestatic

Definition at line 99 of file AppCommon.h.

{ return _jobProgressMax; }

jobProgressMax() [2/2]

static void AppCommon::jobProgressMax ( int  max )

inlinestatic

Definition at line 96 of file AppCommon.h.

{ _jobProgressMax = max; }

jobProgressMsg() [1/2]

string AppCommon::jobProgressMsg ( )

static

Thread-safe getter of the progress message.

Definition at line 392 of file AppCommon.cpp.

{
    lock_guard<mutex> guard(_jobMutex);
    return _jobProgressMsg;
}

jobProgressMsg() [2/2]

void AppCommon::jobProgressMsg ( string  msg )

static

Thread-safe setter of the progress message.

Definition at line 384 of file AppCommon.cpp.

{
    AppCommon::_jobMutex.lock();
    AppCommon::_jobProgressMsg = std::move(msg);
    AppCommon::_jobMutex.unlock();
}

jobProgressNum() [1/2]

static int AppCommon::jobProgressNum ( )

inlinestatic

Definition at line 98 of file AppCommon.h.

{ return _jobProgressNum; }

jobProgressNum() [2/2]

static void AppCommon::jobProgressNum ( int  num )

inlinestatic

Definition at line 95 of file AppCommon.h.

{ _jobProgressNum = num; }

onDoneAssembling()

void AppCommon::onDoneAssembling ( SLSceneView *  sv, SLScene *  s, SLfloat  startLoadMS  )

staticprivate

Definition at line 267 of file AppCommon.cpp.

{
    /* Assign the scene to the sceneview. The sceneview exists and is used
     * before it knows its scene. This is new since we do async loading and
     * show a spinner in the sceneview. */
    sv->scene(s);
    sv->postSceneLoad();
 
    // Make sure the scene view has a camera
    if (!sv->camera())
        sv->camera(sv->sceneViewCamera());
 
    // call onInitialize on all scene views to init the scenegraph and stats
    for (auto* sceneView : AppCommon::sceneViews)
        if (sceneView != nullptr)
            sceneView->onInitialize();
 
    AppCommon::scene = s;
 
    if (App::config.onAfterSceneAssembly)
        App::config.onAfterSceneAssembly(sv, s);
 
    s->loadTimeMS(GlobalTimer::timeMS() - startLoadMS);
}

onDoneLoading()

void AppCommon::onDoneLoading ( SLSceneView *  sv, SLScene *  s, SLfloat  startLoadMS  )

staticprivate

OnDoneLoading is called when the asyn asset loading is finished and the async scene assembly can be started.

Definition at line 248 of file AppCommon.cpp.

{
    SLAssetManager* am = AppCommon::assetManager;
    SLAssetLoader*  al = AppCommon::assetLoader;
 
    // Register a task to assemble the scene.
    al->addLoadTask(std::bind(&SLScene::assemble, s, am, sv));
 
    // `onDone` is a wrapper around `onDoneAssembling` that will be called
    // in the main thread after loading.
    auto onDone = std::bind(onDoneAssembling, sv, s, startLoadMS);
 
    // Start assembling the scene asynchronously.
    al->loadAssetsAsync(onDone);
 
    if (App::config.onBeforeSceneAssembly)
        App::config.onBeforeSceneAssembly(sv, s);
}

registerCoreAssetsLoad()

void AppCommon::registerCoreAssetsLoad ( )

static

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.

Definition at line 143 of file AppCommon.cpp.

{
    SLAssetLoader&  al = *AppCommon::assetLoader;
    SLAssetManager* am = AppCommon::assetManager;
 
    // FIXME: There are dependencies between these load tasks, how do we express this?
 
    // Load all core shader programs.
    al.addLoadTask([am]
                   { SLGLProgramManager::loadPrograms(); });
 
    // Generate static fonts.
    al.addLoadTask([am, fontPath = AppCommon::fontPath]
                   { am->generateStaticFonts(AppCommon::fontPath); });
 
    // Load data for ImGUI fonts.
    al.addRawDataToLoad(AppCommon::fontDataProp,
                        AppCommon::fontPath + "DroidSans.ttf",
                        IOK_font);
    al.addRawDataToLoad(AppCommon::fontDataFixed,
                        AppCommon::fontPath + "ProggyClean.ttf",
                        IOK_font);
}

switchScene()

void AppCommon::switchScene ( SLSceneView *  sv, SLSceneID  sceneID  )

static

Deletes the current scene and creates a new one identified by the sceneID. All assets get registered for async loading while Imgui shows a progress spinner in the UI. After the parallel loading the scene gets assembled back in the main thread.

Parameters

sv	Pointer to the sceneview
sceneID	Scene identifier defined in SLEnum

Definition at line 175 of file AppCommon.cpp.

{
    SLAssetManager*& am = AppCommon::assetManager;
    SLAssetLoader*&  al = AppCommon::assetLoader;
 
    SLfloat startLoadMS = GlobalTimer::timeMS();
 
    //////////////////////
    // Delete old scene //
    //////////////////////
 
    if (App::config.onBeforeSceneDelete)
        App::config.onBeforeSceneDelete(sv, AppCommon::scene);
 
    if (AppCommon::scene)
    {
        delete AppCommon::scene;
        AppCommon::scene = nullptr;
    }
 
    // Deactivate in general the device sensors
    AppCommon::devRot.init();
    AppCommon::devLoc.init();
 
    // reset existing sceneviews
    for (auto* sceneView : AppCommon::sceneViews)
        sceneView->unInit();
 
    // Clear all data in the asset manager
    am->clear();
 
    ////////////////////
    // Init new scene //
    ////////////////////
 
    AppCommon::sceneID = sceneID;
    SLScene* s         = App::config.onNewScene(sceneID);
    SL_LOG("Scene name       : %s (SceneID: %d)",
           s->name().c_str(),
           AppCommon::sceneID);
 
    // Initialize all preloaded stuff from SLScene
    s->init(am);
 
#ifndef SL_EMSCRIPTEN
    s->initOculus(AppCommon::dataPath + "shaders/");
#endif
 
    // Reset the global SLGLState state
    SLGLState::instance()->initAll();
 
    ///////////////////////////////
    // Prepare for async loading //
    ///////////////////////////////
 
    // Register assets on the loader that have to be loaded before assembly.
    al->scene(s);
    s->registerAssetsToLoad(*al);
 
    // `onDone` is a wrapper around `onDoneLoading` that will be called
    // in the main thread after loading.
    auto onDone = std::bind(onDoneLoading, sv, s, startLoadMS);
 
    // Start loading assets asynchronously.
    al->loadAssetsAsync(onDone);
 
    if (App::config.onBeforeSceneLoad)
        App::config.onBeforeSceneLoad(sv, s);
}

Member Data Documentation

_jobMutex

mutex AppCommon::_jobMutex

staticprivate

Mutex to protect parallel access.

Definition at line 127 of file AppCommon.h.

_jobProgressMax

atomic< int > AppCommon::_jobProgressMax

staticprivate

Max. integer progress value.

Definition at line 126 of file AppCommon.h.

_jobProgressMsg

string AppCommon::_jobProgressMsg = ""

staticprivate

Text message to show during progress.

Definition at line 124 of file AppCommon.h.

_jobProgressNum

atomic< int > AppCommon::_jobProgressNum

staticprivate

Integer value to show progress.

Definition at line 125 of file AppCommon.h.

appTag

SLstring AppCommon::appTag = "SLProject"

static

Tag string used in logging.

Definition at line 73 of file AppCommon.h.

asciiLabel

SLstring AppCommon::asciiLabel

static

Initial value:

= R"(
   ______   ___             _         __    ____   ___ 
  / __/ /  / _ \_______    (_)__ ____/ /_  / / /  |_  |
 _\ \/ /__/ ___/ __/ _ \  / / -_) __/ __/ /_  _/ / __/ 
/___/____/_/  /_/  \___/_/ /\__/\__/\__/   /_/(_)____/ 
                      |___/  
)"

SLProject ascii label string.

ASCII Label: https://patorjk.com/software/taag/#p=display&f=Small%20Slant&t=SLProject%204.2.

Definition at line 75 of file AppCommon.h.

assetLoader

SLAssetLoader * AppCommon::assetLoader = nullptr

static

Asset-loader for async asset loading.

Definition at line 60 of file AppCommon.h.

assetManager

SLAssetManager * AppCommon::assetManager = nullptr

static

asset manager is the owner of all assets

Definition at line 59 of file AppCommon.h.

CALIB_FTP_DIR

const string AppCommon::CALIB_FTP_DIR = "calibrations"

static

ftp directory for calibration up and download

Definition at line 117 of file AppCommon.h.

CALIB_FTP_HOST

const string AppCommon::CALIB_FTP_HOST = "pallas.ti.bfh.ch:21"

static

ftp host for calibration up and download

Definition at line 114 of file AppCommon.h.

CALIB_FTP_PWD

const string AppCommon::CALIB_FTP_PWD = "FaAdbD3F2a"

static

ftp login pwd for calibration up and download

Definition at line 116 of file AppCommon.h.

CALIB_FTP_USER

const string AppCommon::CALIB_FTP_USER = "upload"

static

ftp login user for calibration up and download

Definition at line 115 of file AppCommon.h.

calibFilePath

SLstring AppCommon::calibFilePath

static

That's where calibrations are stored and loaded from.

Definition at line 109 of file AppCommon.h.

calibIniPath

SLstring AppCommon::calibIniPath

static

That's where data/calibrations folder is located.

Definition at line 108 of file AppCommon.h.

calibrationEstimator

CVCalibrationEstimator * AppCommon::calibrationEstimator = nullptr

static

Definition at line 107 of file AppCommon.h.

calibrationEstimatorParams

CVCalibrationEstimatorParams AppCommon::calibrationEstimatorParams

static

Definition at line 106 of file AppCommon.h.

configPath

SLstring AppCommon::configPath

static

Default path for calibration files.

Definition at line 81 of file AppCommon.h.

configuration

SLstring AppCommon::configuration = "Release"

static

Debug or Release configuration.

Definition at line 76 of file AppCommon.h.

dataPath

SLstring AppCommon::dataPath

static

Path to data directory (it is set platform dependent)

Definition at line 83 of file AppCommon.h.

deviceParameter

map< string, string > AppCommon::deviceParameter

static

Generic device parameter.

Definition at line 101 of file AppCommon.h.

devLoc

SLDeviceLocation AppCommon::devLoc

static

Mobile device location from GPS.

Definition at line 65 of file AppCommon.h.

devRot

SLDeviceRotation AppCommon::devRot

static

Mobile device rotation from IMU.

Definition at line 64 of file AppCommon.h.

exePath

SLstring AppCommon::exePath

static

executable root path

Definition at line 80 of file AppCommon.h.

externalPath

SLstring AppCommon::externalPath

static

Default path for external file storage.

Definition at line 82 of file AppCommon.h.

fontDataFixed

SLIOBuffer AppCommon::fontDataFixed

static

Definition at line 112 of file AppCommon.h.

fontDataProp

SLIOBuffer AppCommon::fontDataProp

static

Definition at line 111 of file AppCommon.h.

fontPath

SLstring AppCommon::fontPath

static

Path to font images.

Definition at line 87 of file AppCommon.h.

gitBranch

SLstring AppCommon::gitBranch = SL_GIT_BRANCH

static

Current GIT branch.

Definition at line 77 of file AppCommon.h.

gitCommit

SLstring AppCommon::gitCommit = SL_GIT_COMMIT

static

Current GIT commit short hash id.

Definition at line 78 of file AppCommon.h.

gitDate

SLstring AppCommon::gitDate = SL_GIT_DATE

static

Current GIT commit date.

Definition at line 79 of file AppCommon.h.

gui

SLUiInterface * AppCommon::gui = nullptr

static

Pointer to the GUI.

Definition at line 63 of file AppCommon.h.

inputManager

SLInputManager AppCommon::inputManager

static

Input events manager.

Global static objects.

Definition at line 58 of file AppCommon.h.

jobIsRunning

atomic< bool > AppCommon::jobIsRunning

static

True if a parallel job is running.

Definition at line 104 of file AppCommon.h.

jobsToBeThreaded

deque< function< void(void)> > AppCommon::jobsToBeThreaded

static

Queue of functions to be executed in a thread.

Definition at line 102 of file AppCommon.h.

jobsToFollowInMain

deque< function< void(void)> > AppCommon::jobsToFollowInMain

static

Queue of function to follow in the main thread.

Definition at line 103 of file AppCommon.h.

modelPath

SLstring AppCommon::modelPath

static

Path to 3D models.

Definition at line 85 of file AppCommon.h.

name

SLstring AppCommon::name = "SLProjectApp"

static

Application name.

Definition at line 72 of file AppCommon.h.

PROFILE_FTP_DIR

const string AppCommon::PROFILE_FTP_DIR = "profiles"

static

ftp directory for profiles upload

Definition at line 118 of file AppCommon.h.

scene

SLScene * AppCommon::scene = nullptr

static

Pointer to the one and only SLScene instance.

Definition at line 61 of file AppCommon.h.

sceneID

SLSceneID AppCommon::sceneID = SL_EMPTY_SCENE_ID

static

ID of currently loaded scene.

Definition at line 89 of file AppCommon.h.

sceneToLoad

std::optional< SLSceneID > AppCommon::sceneToLoad

static

Scene id to load at start up.

Definition at line 90 of file AppCommon.h.

sceneViews

vector< SLSceneView * > AppCommon::sceneViews

static

Vector of sceneview pointers.

Definition at line 62 of file AppCommon.h.

shaderPath

SLstring AppCommon::shaderPath

static

Path to GLSL shader programs.

Definition at line 84 of file AppCommon.h.

texturePath

SLstring AppCommon::texturePath

static

Path to texture images.

Definition at line 86 of file AppCommon.h.

version

SLstring AppCommon::version = "4.2.001"

static

SLProject version string.

Definition at line 74 of file AppCommon.h.

videoPath

SLstring AppCommon::videoPath

static

Path to video files.

Definition at line 88 of file AppCommon.h.

---

The documentation for this class was generated from the following files:

• AppCommon.h
• AppCommon.cpp