EegeoWorld.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include <string>
#include <vector>
#include "EegeoSDK.h"
#include "Timer.h"
#include "PlatformConfig.h"
#include "WebLoadRequestCompletionCallback.h"
#include "EnvironmentCharacterSet.h"
#include "LoadingScreen.h"
#include "DefaultWorkPool.h"
#include "Tasks.h"
#include "IJpegLoader.h"
#include "Modules.h"
#include "IPlatformAbstractionModule.h"
#include "CoreModule.h"
#include "MapModule.h"
#include "TrafficModule.h"
#include "RoutesModule.h"
#include "RenderingModule.h"
#include "LightingModule.h"
#include "FontsModule.h"
#include "TerrainModelModule.h"
#include "TerrainPresentationModule.h"
#include "TerrainStreamingModule.h"
#include "TransportModelModule.h"
#include "TransportPresentationModule.h"
#include "TransportStreamingModule.h"
#include "BuildingModelModule.h"
#include "BuildingPresentationModule.h"
#include "BuildingStreamingModule.h"
#include "PlaceNamesModelModule.h"
#include "PlaceNamesPresentationModule.h"
#include "PlaceNamesStreamingModule.h"
#include "ShadowModelModule.h"
#include "ShadowPresentationModule.h"
#include "StreamingModule.h"
#include "DebugRenderingModule.h"
#include "AsyncLoadersModule.h"
#include "EnvironmentMaterialModule.h"
#include "DataModule.h"
#include "Web.h"
#include "WorldStateManager.h"
#include "FrameTimer.h"
#include "FrameTimerVisualiser.h"
#include "Profiler.h"
#include "ProfileVisualiser.h"
#include "Rendering.h"
#include "EegeoUpdateParameters.h"
#include "EegeoDrawParameters.h"
#include "EegeoShapes.h"
#include "InteriorHighlightsModule.h"
#include "FeatureInteraction.h"
#include "SearchServiceCredentials.h"
#include "TimeProvider.h"


#define EEGEO_PLATFORM_VERSION_NUMBER "EEGEO_PLATFORM_VERSION_NUMBER_TARGET"
#define EEGEO_PLATFORM_VERSION_HASH "EEGEO_PLATFORM_VERSION_COMMIT_HASH_TARGET"

namespace Eegeo
{
    class EegeoWorld
    {
    private:
        Modules::IPlatformAbstractionModule& m_platformAbstractionModule;
        Eegeo::Location::ILocationService& m_locationService;
        Eegeo::UI::NativeUIFactories& m_nativeInputFactories;
        Concurrency::Tasks::IWorkPool& m_workPool;
        const Eegeo::Config::PlatformConfig m_platformConfig;

        WorldStates::WorldStateManager* m_pWorldStateManager;

        Debug::FrameTimer* m_pFrameTimer;
        Debug::FrameTimerVisualiser* m_pFrameTimerVisualiser;

        Debug::Profile::Profiler* m_pProfiler;
        Debug::Profile::ProfileVisualiser* m_pProfileVisualiser;
        
        Helpers::TimeProvider* m_pTimeProvider;
        
        Web::ApiTokenValidator* m_pApiTokenValidator;
        Web::ApiTokenModel* m_pApiTokenModel;
        Web::ApiTokenService* m_pApiTokenService;
        
        Modules::Core::CoreModule* m_pCoreModule;
        Modules::Map::MapModule* m_pMapModule;
        Modules::Data::DataModule* m_pDataModule;
        Shapes::ShapesModule* m_pShapesModule;
        Modules::Map::MapDebugModule* m_pMapDebugModule;

        Modules::RoutesModule* m_pRoutesModule;
        Modules::TrafficModule* m_pTrafficModule;
        Modules::AnimatedObjectsModule* m_pAnimatedObjectsModule;


        Eegeo::Resources::ResourceSpatialQueryService *m_pResourceSpatialQueryService;
        

        


        Resources::Roads::Navigation::NavigationGraphDebuggingService* m_pNavGraphDebuggingService;
        
        Eegeo::Web::WebConnectivityValidator* m_pWebConnectivityValidator;
        Eegeo::Web::WebConnectivityErrorHandler* m_pWebConnectivityErrorHandler;
        

        
        bool m_waitForInitialLocation;

        void PreDraw(const Rendering::RenderContext& renderContext, Rendering::GLState& glState);
        void DrawWorldPhases(const Rendering::RenderContext& renderContext, Rendering::GLState& glState, Rendering::IRenderableFilter& renderableFilter);
        void DrawAllPhases(const Rendering::RenderContext& renderContext, Rendering::GLState& glState, Rendering::IRenderableFilter& renderableFilter);
        void PostDraw(const Rendering::RenderContext& renderContext, Rendering::GLState& glState);

    public:
        
        EegeoWorld(const std::string& apiToken,
                   Modules::IPlatformAbstractionModule& platformAbstractionModule,
                   Eegeo::Helpers::Jpeg::IJpegLoader& jpegLoader,
                   const Eegeo::Rendering::ScreenProperties& screenProperties,
                   Eegeo::Location::ILocationService& locationService,
                   Eegeo::UI::NativeUIFactories& nativeInputFactories,
                   EnvironmentCharacterSet::Type characterSetType,
                   Eegeo::Config::PlatformConfig platformConfig,
                   IEegeoErrorHandler* pErrorHandler=NULL);

        EegeoWorld(const std::string& apiToken,
                   Modules::IPlatformAbstractionModule& platformAbstractionModule,
                   Eegeo::Helpers::Jpeg::IJpegLoader& jpegLoader,
                   const Eegeo::Rendering::ScreenProperties& screenProperties,
                   Eegeo::Location::ILocationService& locationService,
                   Eegeo::UI::NativeUIFactories& nativeInputFactories,
                   EnvironmentCharacterSet::Type characterSetType,
                   Eegeo::Config::PlatformConfig platformConfig,
                   Eegeo::Search::Service::SearchServiceCredentials* pSearchCredentials,
                   IEegeoErrorHandler* pErrorHandler=NULL
                   );

        ~EegeoWorld();

        Eegeo::Debug::FrameTimer& GetFrameTimer() { return *m_pFrameTimer; }
        Eegeo::Debug::FrameTimerVisualiser& GetFrameTimerVisualiser() { return *m_pFrameTimerVisualiser; }
        Eegeo::Debug::Profile::Profiler& GetProfiler() { return *m_pProfiler; }
        Eegeo::Debug::Profile::ProfileVisualiser& GetProfileVisualiser() { return *m_pProfileVisualiser; }
        
        Eegeo::Concurrency::Tasks::IWorkPool& GetWorkPool() { return m_workPool; }
        
        Eegeo::Resources::ResourceSpatialQueryService &GetResourceSpatialQueryService() { return *m_pResourceSpatialQueryService; }
        
        Eegeo::Resources::Roads::Navigation::NavigationGraphDebuggingService &GetNavigationGraphDebuggingService() { return *m_pNavGraphDebuggingService; }
        
        const Eegeo::Rendering::AsyncTexturing::IAsyncTexture& GetPlaceholderTexture() const;
        const Eegeo::Helpers::GLHelpers::TextureInfo& GetEnvironmentPlaceholderTexture() const;
        
        Eegeo::UI::NativeUIFactories &GetNativeUIFactories() { return m_nativeInputFactories; }
        
        Eegeo::Location::ILocationService &GetLocationService() { return m_locationService; }
        
        Modules::Map::MapModule& GetMapModule() const { return *m_pMapModule; }
        Modules::Map::MapDebugModule& GetMapDebugModule() const { return *m_pMapDebugModule; }
        Modules::Core::CoreModule& GetCoreModule() const { return *m_pCoreModule; }
        Modules::Data::DataModule& GetDataModule() { return *m_pDataModule; }
        Shapes::ShapesModule& GetShapesModule() const { return *m_pShapesModule; }
        Resources::Interiors::Highlights::InteriorHighlightsModule& GetInteriorHighlightsModule() const;
        FeatureInteraction::FeatureInteractionModule& GetFeatureInteractionModule() const { return m_pMapModule->GetFeatureInteractionModule(); }

        Modules::IPlatformAbstractionModule& GetPlatformAbstractionModule() const { return m_platformAbstractionModule; }
        
        Modules::Core::RenderingModule& GetRenderingModule() const { return m_pCoreModule->GetRenderingModule(); }
        Modules::Core::DebugRenderingModule& GetDebugRenderingModule() const { return m_pCoreModule->GetDebugRenderingModule(); }
        Modules::Core::LightingModule& GetLightingModule() const { return m_pCoreModule->GetLightingModule(); }
        Modules::Core::FontsModule& GetFontsModule() const { return m_pCoreModule->GetFontsModule(); }
        Modules::Core::AsyncLoadersModule& GetAsyncLoadersModule() const { return m_pCoreModule->GetAsyncLoadersModule(); }
        Modules::Core::SceneModelsModule& GetSceneModelsModule() const { return m_pCoreModule->GetSceneModelsModule(); }
        
        Modules::Map::Layers::TerrainModelModule& GetTerrainModelModule() const { return m_pMapModule->GetTerrainModelModule(); }
        Modules::Map::Layers::TerrainPresentationModule& GetTerrainPresentationModule() const { return m_pMapModule->GetTerrainPresentationModule(); }
        Modules::Map::Layers::TerrainStreamingModule& GetTerrainStreamingModule() const { return m_pMapModule->GetTerrainStreamingModule(); }

        Modules::Map::Layers::TransportModelModule& GetTransportModelModule() const { return m_pMapModule->GetTransportModelModule(); }
        Modules::Map::Layers::TransportPresentationModule& GetTransportPresentationModule() const { return m_pMapModule->GetTransportPresentationModule(); }
        Modules::Map::Layers::TransportStreamingModule& GetTransportStreamingModule() const { return m_pMapModule->GetTransportStreamingModule(); }

        Modules::Map::Layers::BuildingModelModule& GetBuildingModelModule() const { return m_pMapModule->GetBuildingModelModule(); }
        Modules::Map::Layers::BuildingStreamingModule& GetBuildingStreamingModule() const { return m_pMapModule->GetBuildingStreamingModule(); }
        Modules::Map::Layers::BuildingPresentationModule& GetBuildingPresentationModule() const { return m_pMapModule->GetBuildingPresentationModule(); }
        
        Modules::Map::Layers::PlaceNamesModelModule& GetPlaceNamesModelModule() const { return m_pMapModule->GetPlaceNamesModelModule(); }
        Modules::Map::Layers::PlaceNamesPresentationModule& GetPlaceNamesPresentationModule() const { return m_pMapModule->GetPlaceNamesPresentationModule(); }
        Modules::Map::Layers::PlaceNamesStreamingModule& GetPlaceNamesStreamingModule() const { return m_pMapModule->GetPlaceNamesStreamingModule(); }
        
        Modules::Map::Layers::ShadowModelModule& GetShadowModelModule() const { return m_pMapModule->GetShadowModelModule(); }
        Modules::Map::Layers::ShadowPresentationModule& GetShadowPresentationModule() const { return m_pMapModule->GetShadowPresentationModule(); }
        
        Modules::Map::StreamingModule& GetStreamingModule() const { return m_pMapModule->GetStreamingModule(); }
        Modules::Map::CityThemesModule& GetCityThemesModule() const { return m_pMapModule->GetCityThemesModule(); }
        Modules::Map::EnvironmentMaterialModule& GetEnvironmentMaterialModule() const { return m_pMapModule->GetEnvironmentMaterialModule(); }
        Modules::Map::WeatherModule& GetWeatherModule() const { return m_pMapModule->GetWeatherModule(); }
        Modules::Map::CoverageTreeModule& GetCoverageTreeModule() const { return m_pMapModule->GetCoverageTreeModule(); }

        Modules::TrafficModule& GetTrafficModule() const { return *m_pTrafficModule; }
        Modules::RoutesModule& GetRoutesModule() const { return *m_pRoutesModule; }
        Modules::AnimatedObjectsModule& GetAnimatedObjectsModule() const { return *m_pAnimatedObjectsModule; }
        
        Eegeo::Web::WebConnectivityValidator& GetWebConnectivityValidator() const { return *m_pWebConnectivityValidator; }
        Web::ApiTokenService& GetApiTokenService();
        Web::ApiTokenModel& GetApiTokenModel();
        
        bool GetWaitForInitialLocation() const { return m_waitForInitialLocation; }
        void SetWaitForInitialLocation(bool wait) { m_waitForInitialLocation = wait; }
        
        bool IsStreaming(bool includePrecacheService) const;

        const bool Initialising() const;
        const bool Validated() const;
        
        void EarlyUpdate(float dt);
        void Update(const EegeoUpdateParameters& updateParameters);
        void Draw(const EegeoDrawParameters& drawParameters, Rendering::IRenderableFilter& renderableFilter);
        void Draw(const EegeoDrawParameters& drawParameters);
        void OnPause();
        void OnResume();
        
        float GetInitialisationProgress() const;

        void InitialiseWorldStates();
        void TeardownWorldStates();
    };
}