IconsModule.h

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

#pragma once

#include "Types.h"
#include "Icons.h"
#include "AsyncTexturing.h"
#include "Helpers.h"
#include "IconSet.h"
#include "Modules.h"
#include "Text.h"
#include "Rendering.h"
#include "AllVertexTypes.h"
#include "RenderableFilters.h"
#include "Config.h"
#include "IconsModuleConfiguration.h"

namespace Eegeo
{
    namespace Icons
    {
        class IconsModule : private Eegeo::NonCopyable
        {
        public:
            
            
            ~IconsModule();
            
            static IconsModule* Create(Helpers::IFileIO& fileIO,
                                       Modules::Core::AsyncLoadersModule& asyncLoadersModule,
                                       Modules::Core::RenderingModule& renderingModule,
                                       const Config::PlatformConfig& platformConfig);
            
            void PreDraw();
            
            IScreenIconRenderer& GetScreenIconRenderer() const { return *m_pScreenIconRenderer; }
            IWorldIconRenderer& GetWorldIconRenderer() const { return *m_pWorldIconRenderer; }
            Rendering::IRenderableFilter& GetRenderableFilters() const { return *m_pRenderableFilters; }
            
            const IconSet& GetEnvironmentIconSet() const;
            
            static IconsModuleConfiguration DefaultConfig();
            
        private:
            
            
            IconsModule(const std::string& pinSheetManifestPath,
                        bool iconsEnabled,
                        IconSetRepository* pIconSetRepository,
                        IconSetLoader* pIconSetLoader,
                        IconSetService* pIconSetService,
                        Text::GlBuffer<Rendering::VertexTypes::ScreenTextVertex>* pScreenIconVertexBuffer,
                        Text::GlBuffer<Rendering::VertexTypes::WorldTextVertex>* pWorldIconVertexBuffer,
                        const Text::GlBuffer<u16>* pQuadIndexBuffer,
                        IBatchedScreenIconRenderableFactory* pBatchedScreenIconRenderableFactory,
                        IBatchedWorldIconRenderableFactory* pBatchedWorldIconRenderableFactory,
                        Rendering::Shaders::BatchedIconShader* pShader,
                        IconMaterialSetFactory* pIconMaterialSetFactory,
                        IconMaterialSetCache* pIconMaterialSetCache,
                        IScreenIconRenderer* pScreenIconRenderer,
                        IWorldIconRenderer* pWorldIconRenderer,
                        Rendering::RenderableFilters* pRenderableFilters);
            
            void LoadResources(const std::string& iconSetJsonPath);
            
            
            IconSetRepository* m_pIconSetRepository;
            IconSetLoader* m_pIconSetLoader;
            IconSetService* m_pIconSetService;
            
            IconSet::TIdType m_environmentIconSet;
            
            Text::GlBuffer<Rendering::VertexTypes::ScreenTextVertex>* m_pScreenIconVertexBuffer;
            Text::GlBuffer<Rendering::VertexTypes::WorldTextVertex>* m_pWorldIconVertexBuffer;
            const Text::GlBuffer<u16>* m_pQuadIndexBuffer;
            IBatchedScreenIconRenderableFactory* m_pBatchedScreenIconRenderableFactory;
            IBatchedWorldIconRenderableFactory* m_pBatchedWorldIconRenderableFactory;
            Rendering::Shaders::BatchedIconShader* m_pShader;
            IconMaterialSetFactory* m_pIconMaterialSetFactory;
            IconMaterialSetCache* m_pIconMaterialSetCache;
            IScreenIconRenderer* m_pScreenIconRenderer;
            IWorldIconRenderer* m_pWorldIconRenderer;
            Rendering::RenderableFilters* m_pRenderableFilters;
            
        };
    }
}