CityThemesTextureUpdater.h

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

#pragma once

#include "Types.h"
#include "Rendering.h"
#include "Helpers.h"
#include "Web.h"
#include "CityThemes.h"
#include "WebLoadRequestCompletionCallback.h"
#include "GLHelpers.h"
#include <string>
#include <vector>
#include <map>
#include <set>
#include "PendingWebRequestsContainer.h"
#include "IAsyncCubeTextureRequestor.h"
#include "AsyncTexturing.h"
#include "AsyncLoadersModule.h"
#include "IAsyncTextureObserver.h"
#include "PendingAsyncTextureLoadsContainer.h"
#include "ICallback.h"
#include "ITextureFileLoader.h"
#include <cstdint>

namespace Eegeo
{
    namespace Resources
    {
        namespace CityThemes
        {
            class CityThemesTextureUpdater : public Eegeo::Rendering::AsyncTexturing::IAsyncTextureObserver, protected Eegeo::NonCopyable
            {
            private:
                Rendering::EnvironmentTextures& m_environmentTextures;
                Eegeo::Helpers::ITextureFileLoader& m_textureLoader;
                Web::IWebLoadRequestFactory& m_webRequestFactory;
                Web::TWebLoadRequestCompletionCallback<CityThemesTextureUpdater> m_themeTextureDownloadedHandler;
                Eegeo::Helpers::IHttpCache& m_httpCache;

                std::set<std::string> m_inFlightCubeTextures;
                Eegeo::Modules::Core::AsyncLoadersModule& m_asyncLoadersModule;
                
                std::uintptr_t m_themeChangeCount;
                int m_currentThemeTexturesCount;
                bool m_textureLoadingFailed;
                
                struct TextureInfoRefs
                {
                    bool used;
                    Eegeo::Helpers::GLHelpers::TextureInfo info;
                };
                
                
                std::map<std::string, TextureInfoRefs> m_loadedTextures;
                Web::PendingWebRequestsContainer m_pendingWebRequestsContainer;

                Helpers::TCallback1<CityThemesTextureUpdater, const Rendering::AsyncTexturing::AsyncTextureLoadResult> m_asyncTextureLoadCallback;
                Rendering::AsyncTexturing::PendingAsyncTextureLoadsContainer m_pendingAsyncTextureLoadsContainer;
                
            public:
                CityThemesTextureUpdater(Rendering::EnvironmentTextures& environmentTextures,
                                         Web::IWebLoadRequestFactory& webRequestFactory,
                                         Eegeo::Helpers::ITextureFileLoader& textureLoader,
                                         Eegeo::Helpers::IHttpCache& httpCache,
                                         Eegeo::Modules::Core::AsyncLoadersModule& asyncLoadersModule
                                         );
                
                void DownloadThemeTextures(const CityThemeData& targetTheme);
                bool IsLoading() const { return NumberOfTexturesInFlight() > 0; }
                int CurrentThemeTexturesToLoad() const { return m_currentThemeTexturesCount; }
                int CurrentThemeTexturesLoaded() const { return m_currentThemeTexturesCount - NumberOfTexturesInFlight(); }
                bool LoadsFailed() const { return m_textureLoadingFailed; }
                void CleanupRedundantLoads();
                void ApplyThemeTextures(const CityThemeData& themeData);

                void OnTextureLoadSuccess(const Eegeo::Rendering::AsyncTexturing::IAsyncTexture& loadedTexture);
                void OnTextureLoadFail(const Eegeo::Rendering::AsyncTexturing::IAsyncTexture& loadedTexture);
                
            private:
                void ThemeTextureDownloadedHandler(Eegeo::Web::IWebResponse& webResponse);
                void BeginTextureDownload(const std::string& textureName);
                void BeginCubeMapTextureDownload(const std::string& textureUrl);

                void BeginTextureDownloads(const std::vector<std::string>& textureUrls);
                
                bool TryLoadTextureFromBufferAsync(
                    const std::string& url,
                    const std::vector<Byte>& buffer);

                void OnTextureAsyncLoadComplete(const Rendering::AsyncTexturing::AsyncTextureLoadResult& result);

                void LoadLocalTextureFromResource(const std::string& url);

                Rendering::AsyncTexturing::IAsyncTexture& GetAndUseEnvironmentTexture(const std::string& textureFilename);

                int NumberOfTexturesInFlight() const;
            };
        }
    }
}