AppDemoMain.cpp File Reference

This file has the main function of the demo app of SLProject. More...

#include <App.h>
#include <AppCommon.h>
#include <AppDemoGui.h>
#include <AppDemoSceneView.h>
#include <AppDemoSceneID.h>
#include <SLGLState.h>
#include <SLEnums.h>
#include <CVCapture.h>
#include <AppDemoScene2Dand3DText.h>
#include <AppDemoSceneAnimNode.h>
#include <AppDemoSceneAnimNodeMass.h>
#include <AppDemoSceneAnimNodeMass2.h>
#include <AppDemoSceneAnimSkinned.h>
#include <AppDemoSceneAnimSkinnedMass.h>
#include <AppDemoSceneAnimSkinnedMass2.h>
#include <AppDemoSceneEmpty.h>
#include <AppDemoSceneErlebARBielBFH.h>
#include <AppDemoSceneErlebARAugustaTmpTht.h>
#include <AppDemoSceneErlebARAventicumCigognier.h>
#include <AppDemoSceneErlebARAventicumTheater.h>
#include <AppDemoSceneErlebARAventicumAmphitheater.h>
#include <AppDemoSceneErlebARBernChristoffel.h>
#include <AppDemoSceneErlebARSutz.h>
#include <AppDemoSceneFigure.h>
#include <AppDemoSceneFrustum.h>
#include <AppDemoSceneGLTF.h>
#include <AppDemoSceneJansUniverse.h>
#include <AppDemoSceneMeshLoad.h>
#include <AppDemoSceneMinimal.h>
#include <AppDemoSceneLargeModel.h>
#include <AppDemoSceneLevelOfDetail.h>
#include <AppDemoSceneLotsOfNodes.h>
#include <AppDemoSceneParticleComplexFire.h>
#include <AppDemoSceneParticleDustStorm.h>
#include <AppDemoSceneParticleFountain.h>
#include <AppDemoSceneParticleMany.h>
#include <AppDemoSceneParticleRingOfFire.h>
#include <AppDemoSceneParticleSimple.h>
#include <AppDemoSceneParticleSun.h>
#include <AppDemoScenePointClouds.h>
#include <AppDemoSceneRevolver.h>
#include <AppDemoSceneRTDoF.h>
#include <AppDemoSceneRTMuttenzerBox.h>
#include <AppDemoSceneRTLens.h>
#include <AppDemoSceneRTSpheres.h>
#include <AppDemoSceneRobot.h>
#include <AppDemoSceneSuzanne.h>
#include <AppDemoSceneShaderBlinn.h>
#include <AppDemoSceneShaderBump.h>
#include <AppDemoSceneShaderCook.h>
#include <AppDemoSceneShaderEarth.h>
#include <AppDemoSceneShaderIBL.h>
#include <AppDemoSceneShaderParallax.h>
#include <AppDemoSceneShaderSkybox.h>
#include <AppDemoSceneShaderWave.h>
#include <AppDemoSceneShadowBasic.h>
#include <AppDemoSceneShadowCascaded.h>
#include <AppDemoSceneShadowLightTypes.h>
#include <AppDemoSceneShadowLightSpot.h>
#include <AppDemoSceneShadowLightPoint.h>
#include <AppDemoSceneTextureBlend.h>
#include <AppDemoSceneTextureCompression.h>
#include <AppDemoSceneTextureFilter.h>
#include <AppDemoSceneVideoSensorAR.h>
#include <AppDemoSceneVideoTexture.h>
#include <AppDemoSceneVideoTrackAruco.h>
#include <AppDemoSceneVideoTrackChessboard.h>
#include <AppDemoSceneVideoTrackFace.h>
#include <AppDemoSceneVideoTrackFeatures.h>
#include <AppDemoSceneVideoTrackMediapipe.h>
#include <AppDemoSceneVideoTrackWAI.h>
#include <AppDemoSceneVolumeRayCast.h>
#include <AppDemoSceneVolumeRayCastLighted.h>
#include <AppDemoSceneZFighting.h>
#include <CVTracked.h>

Go to the source code of this file.

Functions
bool	onUpdateVideo ()
	Implements the update per frame for video update and feature tracking. More...
static SLSceneView *	createSceneView (SLScene *scene, int curDPI, SLInputManager &inputManager)
static SLScene *	createScene (SLSceneID sceneID)
static void	onBeforeSceneDelete (SLSceneView *sv, SLScene *s)
static void	onBeforeSceneLoad (SLSceneView *sv, SLScene *s)
static void	onBeforeSceneAssembly (SLSceneView *sv, SLScene *s)
static void	onAfterSceneAssembly (SLSceneView *sv, SLScene *s)
static SLbool	onUpdate (SLSceneView *sv)
int	SL_MAIN_FUNCTION (int argc, char *argv[])

Variables
SLGLTexture *	gVideoTexture
CVTracked *	gVideoTracker
SLNode *	gVideoTrackedNode

Detailed Description

This file has the main function of the demo app of SLProject.

An App::Config is set and then passed to the run function defined App.h. Beside this is contains the callback functions for the scene creation. See App.h for their typedef. 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: https://cpvrlab.github.io/SLProject4/app-framework.html

Authors

Marcus Hudritsch, Marino von Wattenwyl

Date

July 2024

Copyright

http://opensource.org/licenses/GPL-3.0

Remarks

Please use clangformat to format the code. See more code style on https://github.com/cpvrlab/SLProject4/wiki/SLProject-Coding-Style

Definition in file AppDemoMain.cpp.

Function Documentation

createScene()

static SLScene* createScene ( SLSceneID  sceneID )

static

Definition at line 117 of file AppDemoMain.cpp.

{
    switch (sceneID)
    {
        case SID_Empty: return new AppDemoSceneEmpty();
        case SID_Figure: return new AppDemoSceneFigure();
        case SID_Minimal: return new AppDemoSceneMinimal();
        case SID_MeshLoad: return new AppDemoSceneMeshLoad();
        case SID_Revolver: return new AppDemoSceneRevolver();
        case SID_TextureBlend: return new AppDemoSceneTextureBlend();
        case SID_TextureFilter: return new AppDemoSceneTextureFilter();
#ifdef SL_BUILD_WITH_KTX
        case SID_TextureCompression: return new AppDemoSceneTextureCompression();
#endif
        case SID_FrustumCull: return new AppDemoSceneFrustum();
        case SID_2Dand3DText: return new AppDemoScene2Dand3DText();
        case SID_PointClouds: return new AppDemoScenePointClouds();
        case SID_ZFighting: return new AppDemoSceneZFighting();
        case SID_ShaderPerVertexBlinn: return new AppDemoSceneShaderBlinn("Per Vertex Blinn-Phong Lighting", true);
        case SID_ShaderPerPixelBlinn: return new AppDemoSceneShaderBlinn("Per Pixel Blinn-Phong Lighting", false);
        case SID_ShaderPerPixelCook: return new AppDemoSceneShaderCook();
        case SID_ShaderIBL: return new AppDemoSceneShaderIBL();
        case SID_ShaderWave: return new AppDemoSceneShaderWave();
        case SID_ShaderBumpNormal: return new AppDemoSceneShaderBump();
        case SID_ShaderBumpParallax: return new AppDemoSceneShaderParallax();
        case SID_ShaderSkybox: return new AppDemoSceneShaderSkybox();
        case SID_ShaderEarth: return new AppDemoSceneShaderEarth();
        case SID_ShadowMappingBasicScene: return new AppDemoSceneShadowBasic();
        case SID_ShadowMappingLightTypes: return new AppDemoSceneShadowLightTypes();
        case SID_ShadowMappingSpotLights: return new AppDemoSceneShadowLightSpot();
        case SID_ShadowMappingPointLights: return new AppDemoSceneShadowLightPoint();
        case SID_ShadowMappingCascaded: return new AppDemoSceneShadowCascaded();
        case SID_SuzannePerPixBlinn: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting and reflection colors", false, false, false, false, false);
        case SID_SuzannePerPixBlinnTm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting and texture mapping", true, false, false, false, false);
        case SID_SuzannePerPixBlinnNm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting and normal mapping", false, true, false, false, false);
        case SID_SuzannePerPixBlinnAo: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting and ambient occlusion", false, false, true, false, false);
        case SID_SuzannePerPixBlinnSm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting and shadow mapping", false, false, false, true, false);
        case SID_SuzannePerPixBlinnTmNm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting, texture and normal mapping", true, true, false, false, false);
        case SID_SuzannePerPixBlinnTmAo: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting, texture mapping and ambient occlusion", true, false, true, false, false);
        case SID_SuzannePerPixBlinnNmAo: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting, normal mapping and ambient occlusion", false, true, true, false, false);
        case SID_SuzannePerPixBlinnTmSm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting, texture mapping and shadow mapping", true, false, false, true, false);
        case SID_SuzannePerPixBlinnNmSm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting, normal mapping and shadow mapping", false, true, false, true, false);
        case SID_SuzannePerPixBlinnAoSm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting, ambient occlusion and shadow mapping", false, false, true, true, false);
        case SID_SuzannePerPixBlinnTmNmAo: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting and diffuse, normal, ambient occlusion and shadow mapping", true, true, true, false, false);
        case SID_SuzannePerPixBlinnTmNmSm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting and diffuse, normal and shadow mapping ", true, true, false, true, false);
        case SID_SuzannePerPixBlinnTmNmAoSm: return new AppDemoSceneSuzanne("Suzanne with per pixel Blinn-Phong lighting and diffuse, normal, ambient occlusion and shadow mapping", true, true, true, true, false);
        case SID_SuzannePerPixCookTmNmAoSmEm: return new AppDemoSceneSuzanne("Suzanne with per pixel Cook-Torrance lighting and diffuse, normal, ambient occlusion, shadow and environment mapping", true, true, true, true, true);
        case SID_glTF_DamagedHelmet:
        case SID_glTF_FlightHelmet:
        case SID_glTF_Sponza:
        case SID_glTF_WaterBottle: return new AppDemoSceneGLTF(sceneID);
        case SID_Robotics_FanucCRX_FK: return new AppDemoSceneRobot();
        case SID_VolumeRayCast: return new AppDemoSceneVolumeRayCast();
        case SID_VolumeRayCastLighted: return new AppDemoSceneVolumeRayCastLighted();
        case SID_AnimationNode: return new AppDemoSceneAnimNode();
        case SID_AnimationNodeMass: return new AppDemoSceneAnimNodeMass();
        case SID_AnimationSkinned: return new AppDemoSceneAnimSkinned();
        case SID_AnimationSkinnedMass: return new AppDemoSceneAnimSkinnedMass();
        case SID_VideoTextureFile:
        case SID_VideoTextureLive: return new AppDemoSceneVideoTexture(sceneID);
        case SID_VideoTrackChessMain:
        case SID_VideoTrackChessScnd:
        case SID_VideoCalibrateMain:
        case SID_VideoCalibrateScnd: return new AppDemoSceneVideoTrackChessboard(sceneID);
        case SID_VideoTrackArucoMain:
        case SID_VideoTrackArucoScnd: return new AppDemoSceneVideoTrackAruco(sceneID);
        case SID_VideoTrackFaceMain:
        case SID_VideoTrackFaceScnd: return new AppDemoSceneVideoTrackFace(sceneID);
        case SID_VideoTrackFeature2DMain: return new AppDemoSceneVideoTrackFeatures();
        case SID_VideoTrackMediaPipeHandsMain: return new AppDemoSceneVideoTrackMediapipe();
        case SID_VideoTrackWAI: return new AppDemoSceneVideoTrackWAI();
        case SID_VideoSensorAR: return new AppDemoSceneVideoSensorAR();
        case SID_ParticleSystem_Simple: return new AppDemoSceneParticleSimple();
        case SID_ParticleSystem_DustStorm: return new AppDemoSceneParticleDustStorm();
        case SID_ParticleSystem_Fountain: return new AppDemoSceneParticleFountain();
        case SID_ParticleSystem_Sun: return new AppDemoSceneParticleSun();
        case SID_ParticleSystem_RingOfFire: return new AppDemoSceneParticleRingOfFire();
        case SID_ParticleSystem_ComplexFire:
        case SID_Benchmark_ParticleSystemComplexFire: return new AppDemoSceneParticleComplexFire(sceneID);
        case SID_ParticleSystem_Many: return new AppDemoSceneParticleMany();
        case SID_RTSpheres:
        case SID_RTSoftShadows: return new AppDemoSceneRTSpheres(sceneID);
        case SID_RTMuttenzerBox: return new AppDemoSceneRTMuttenzerBox();
        case SID_RTDoF: return new AppDemoSceneRTDoF();
        case SID_RTLens: return new AppDemoSceneRTLens();
        case SID_Benchmark_JansUniverse: return new AppDemoSceneJansUniverse();
        case SID_Benchmark_NodeAnimations: return new AppDemoSceneAnimNodeMass2();
        case SID_Benchmark_LargeModel: return new AppDemoSceneLargeModel();
        case SID_Benchmark_LotsOfNodes: return new AppDemoSceneLotsOfNodes();
        case SID_Benchmark_ColumnsLOD:
        case SID_Benchmark_ColumnsNoLOD: return new AppDemoSceneLevelOfDetail(sceneID);
        case SID_Benchmark_SkinnedAnimations: return new AppDemoSceneAnimSkinnedMass2();
        case SID_ErlebAR_BernChristoffel: return new AppDemoSceneErlebARBernChristoffel();
        case SID_ErlebAR_BielBFH: return new AppDemoSceneErlebARBielBFH();
        case SID_ErlebAR_AugustaRauricaTmpTht: return new AppDemoSceneErlebARAugustaTmpTht();
        case SID_ErlebAR_AventicumCigognier: return new AppDemoSceneErlebARAventicumCigognier();
        case SID_ErlebAR_AventicumTheatre: return new AppDemoSceneErlebARAventicumTheater();
        case SID_ErlebAR_AventicumAmphiteatre: return new AppDemoSceneErlebARAventicumAmphitheater();
        case SID_ErlebAR_SutzKirchrain18: return new AppDemoSceneErlebARSutz();
        default: SL_EXIT_MSG("appDemoSwitchScene: Unknown SceneID");
    }
}

createSceneView()

static SLSceneView* createSceneView ( SLScene *  scene, int  curDPI, SLInputManager &  inputManager  )

static

Definition at line 109 of file AppDemoMain.cpp.

{
    // The sceneview will be deleted by SLScene::~SLScene()
    return new AppDemoSceneView(scene, curDPI, inputManager);
}

onAfterSceneAssembly()

static void onAfterSceneAssembly ( SLSceneView *  sv, SLScene *  s  )

static

Definition at line 244 of file AppDemoMain.cpp.

{
    if (CVCapture::instance()->videoType() != VT_NONE)
    {
        if (sv->viewportSameAsVideo())
        {
            // Pass a negative value to the start function, so that the
            // viewport aspect ratio can be adapted later to the video aspect.
            // This will be known after start.
            CVCapture::instance()->start(-1.0f);
            SLVec2i videoAspect;
            videoAspect.x = CVCapture::instance()->captureSize.width;
            videoAspect.y = CVCapture::instance()->captureSize.height;
            sv->setViewportFromRatio(videoAspect,
                                     sv->viewportAlign(),
                                     true);
        }
        else
            CVCapture::instance()->start(sv->viewportWdivH());
    }
}

onBeforeSceneAssembly()

static void onBeforeSceneAssembly ( SLSceneView *  sv, SLScene *  s  )

static

Definition at line 239 of file AppDemoMain.cpp.

{
    AppDemoGui::loadingString = "Assembling ...";
}

onBeforeSceneDelete()

static void onBeforeSceneDelete ( SLSceneView *  sv, SLScene *  s  )

static

Definition at line 220 of file AppDemoMain.cpp.

{
    // Reset video and trackers
    CVCapture::instance()->videoType(VT_NONE); // turn off any video
    CVTracked::resetTimes();                   // delete all gVideoTracker times
    delete gVideoTracker;                      // delete the tracker deep
    gVideoTracker     = nullptr;
    gVideoTexture     = nullptr; // The video texture will be deleted by scene uninit
    gVideoTrackedNode = nullptr; // The tracked node will be deleted by scene uninit
 
    // Clear gui stuff that depends on scene and sceneview
    AppDemoGui::clear();
}

onBeforeSceneLoad()

static void onBeforeSceneLoad ( SLSceneView *  sv, SLScene *  s  )

static

Definition at line 234 of file AppDemoMain.cpp.

{
    AppDemoGui::loadingString = "Loading ...";
}

onUpdate()

static SLbool onUpdate ( SLSceneView *  sv )

static

Definition at line 266 of file AppDemoMain.cpp.

{
    // If live video image is requested grab it and copy it
    if (CVCapture::instance()->videoType() != VT_NONE)
    {
        float viewportWdivH = sv->viewportWdivH();
        CVCapture::instance()->grabAndAdjustForSL(viewportWdivH);
    }
 
    SLbool trackingGotUpdated = onUpdateVideo();
    return trackingGotUpdated;
}

onUpdateVideo()

bool onUpdateVideo

(

)

Implements the update per frame for video update and feature tracking.

This routine is called once per frame before any other update within the the main rendering loop (see: AppDemoMainGLFW::onPaint or GLES3View::onDrawFrame). See the documentation within SLCVTracked and in all of its inheritants.

Definition at line 226 of file AppDemoVideo.cpp.

{
    PROFILE_FUNCTION();
 
    if (AppCommon::sceneViews.empty())
        return false;
 
    SLScene*     s  = AppCommon::scene;
    SLSceneView* sv = AppCommon::sceneViews[0];
 
    if (CVCapture::instance()->videoType() != VT_NONE &&
        !CVCapture::instance()->lastFrame.empty())
    {
        SLfloat trackingTimeStartMS = GlobalTimer::timeMS();
 
        CVCamera* ac = CVCapture::instance()->activeCamera;
 
        if (AppCommon::sceneID == SID_VideoCalibrateMain ||
            AppCommon::sceneID == SID_VideoCalibrateScnd)
        {
            runCalibrationEstimator(ac, s, sv);
        }
        else
        {
            ensureValidCalibration(ac, sv);
            // Attention: Always update scene camera fovV from calibration because the calibration may have
            // been adapted in adjustForSL after a change of aspect ratio!
            // The active scene view camera may be a different one that the tracking camera
            // but we have to update the tracking camera only!
            updateTrackingSceneCamera(ac);
 
            if (gVideoTracker && gVideoTrackedNode)
            {
                bool foundPose = gVideoTracker->track(CVCapture::instance()->lastFrameGray,
                                                      CVCapture::instance()->lastFrame,
                                                      &ac->calibration);
                if (foundPose)
                {
                    // clang-format off
                    // convert matrix type CVMatx44f to SLMat4f
                    CVMatx44f cvOVM = gVideoTracker->objectViewMat();
                    SLMat4f glOVM(cvOVM.val[0], cvOVM.val[1], cvOVM.val[2], cvOVM.val[3],
                                  cvOVM.val[4], cvOVM.val[5], cvOVM.val[6], cvOVM.val[7],
                                  cvOVM.val[8], cvOVM.val[9], cvOVM.val[10],cvOVM.val[11],
                                  cvOVM.val[12],cvOVM.val[13],cvOVM.val[14],cvOVM.val[15]);
                    // clang-format on
 
                    // set the object matrix depending if the
                    // tracked node is attached to a camera or not
                    if (typeid(*gVideoTrackedNode) == typeid(SLCamera))
                    {
                        gVideoTrackedNode->om(glOVM.inverted());
                        gVideoTrackedNode->setDrawBitsRec(SL_DB_HIDDEN, true);
                    }
                    else
                    {
                        // see comments in CVTracked::calcObjectMatrix
                        gVideoTrackedNode->om(sv->camera()->om() * glOVM);
                        gVideoTrackedNode->setDrawBitsRec(SL_DB_HIDDEN, false);
                    }
                }
                else
                    gVideoTrackedNode->setDrawBitsRec(SL_DB_HIDDEN, false);
            }
 
            // Update info text only for chessboard scene
            if (AppCommon::sceneID == SID_VideoCalibrateMain ||
                AppCommon::sceneID == SID_VideoCalibrateScnd ||
                AppCommon::sceneID == SID_VideoTrackChessMain ||
                AppCommon::sceneID == SID_VideoTrackChessScnd)
            {
                SLfloat      fovH = ac->calibration.cameraFovHDeg();
                SLfloat      err  = ac->calibration.reprojectionError();
                stringstream ss; // info line text
                ss << "Tracking Chessboard on " << (CVCapture::instance()->videoType() == VT_MAIN ? "main " : "scnd. ") << "camera. ";
                if (ac->calibration.state() == CS_calibrated)
                    ss << "FOVH: " << fovH << ", error: " << err;
                else
                    ss << "Not calibrated. FOVH guessed: " << fovH << " degrees.";
                s->info(ss.str());
            }
        }
 
        //...................................................................
        // copy image to video texture
        if (gVideoTexture)
        {
            if (ac->calibration.state() == CS_calibrated && ac->showUndistorted())
            {
                CVMat undistorted;
                ac->calibration.remap(CVCapture::instance()->lastFrame, undistorted);
 
                // CVCapture::instance()->gVideoTexture()->copyVideoImage(undistorted.cols,
                gVideoTexture->copyVideoImage(undistorted.cols,
                                              undistorted.rows,
                                              CVCapture::instance()->format,
                                              undistorted.data,
                                              undistorted.isContinuous(),
                                              true);
            }
            else
            {
                // CVCapture::instance()->gVideoTexture()->copyVideoImage(CVCapture::instance()->lastFrame.cols,
                gVideoTexture->copyVideoImage(CVCapture::instance()->lastFrame.cols,
                                              CVCapture::instance()->lastFrame.rows,
                                              CVCapture::instance()->format,
                                              CVCapture::instance()->lastFrame.data,
                                              CVCapture::instance()->lastFrame.isContinuous(),
                                              true);
            }
        }
        else
            SL_WARN_MSG("No video texture to copy to.");
 
#ifndef SL_EMSCRIPTEN
        CVTracked::trackingTimesMS.set(GlobalTimer::timeMS() - trackingTimeStartMS);
#endif
 
        return true;
    }
 
    return false;
}

SL_MAIN_FUNCTION()

int SL_MAIN_FUNCTION	(	int	argc,
		char *	argv[]
	)

Definition at line 285 of file AppDemoMain.cpp.

{
    App::Config config;
    config.argc                  = argc;
    config.argv                  = argv;
    config.windowWidth           = 1280;
    config.windowHeight          = 720;
    config.windowTitle           = "SLProject Test Application";
    config.numSamples            = 4;
    config.startSceneID          = SL_STARTSCENE;
    config.onNewSceneView        = createSceneView;
    config.onNewScene            = createScene;
    config.onBeforeSceneDelete   = onBeforeSceneDelete;
    config.onBeforeSceneLoad     = onBeforeSceneLoad;
    config.onBeforeSceneAssembly = onBeforeSceneAssembly;
    config.onAfterSceneAssembly  = onAfterSceneAssembly;
    config.onUpdate              = onUpdate;
    config.onGuiBuild            = AppDemoGui::build;
    config.onGuiLoadConfig       = AppDemoGui::loadConfig;
    config.onGuiSaveConfig       = AppDemoGui::saveConfig;
 
    return App::run(config);
}

Variable Documentation

gVideoTexture

SLGLTexture* gVideoTexture

extern

Global pointer for the video texture defined in AppDemoLoad for video scenes It gets updated in the following onUpdateTracking routine

Definition at line 32 of file AppDemoVideo.cpp.

gVideoTrackedNode

SLNode* gVideoTrackedNode

extern

Global pointer to a node that from witch the gVideoTracker changes the pose. it gets updated in the following onUpdateTracking routine

Definition at line 42 of file AppDemoVideo.cpp.

gVideoTracker

CVTracked* gVideoTracker

extern

Global pointer for a gVideoTracker that is set in AppDemoLoad for video scenes It gets updated in the following onUpdateTracking routine

Definition at line 37 of file AppDemoVideo.cpp.