HttpAsyncTextureLoader.h

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

#pragma once

#include "Types.h"
#include "IAsyncTextureRequestor.h"
#include "Web.h"
#include "Helpers.h"
#include "GLHelpers.h"
#include "IdTypes.h"
#include "WebLoadRequestCompletionCallback.h"
#include <map>
#include <deque>
#include <string>
#include <vector>
#include "PendingWebRequestsContainer.h"
#include "PendingAsyncTextureLoadsContainer.h"
#include "ICallback.h"
#include "ITextureFileLoader.h"

namespace Eegeo
{
    namespace Rendering
    {
        namespace AsyncTexturing
        {
            typedef std::vector<Rendering::AsyncTexturing::IAsyncTexture*> TIAsyncTextures;
            
            class HttpAsyncTextureLoader : protected Eegeo::NonCopyable, public IAsyncTextureRequestor
            {
            public:
                HttpAsyncTextureLoader(
                                      Web::IWebLoadRequestFactory& webLoadRequestFactory,
                                      Eegeo::Helpers::IHttpCache& httpCache,
                                      Eegeo::Helpers::ITextureFileLoader& textureLoader,
                                      IAsyncTexture& placeholderTexture,
                                      ITextureFactory& textureFactory
                                      );
              
               ~HttpAsyncTextureLoader();
                
                IAsyncTexture& RequestTexture(const std::string& textureUrl,
                                              IAsyncTextureObserver* pObserver,
                                              bool generateMipmaps=false,
                                              bool tryToUpdateIfModified=false);
                
                void Release(const HttpAsyncTexture& textureToRelease);
                void DestroyTexture(const HttpAsyncTexture& textureToRelease);
                
                void IssueNextLoadRequest();
                bool HasPendingLoadRequests() const;
                void UpdatePlaceholderEnvironmentTexture(Rendering::AsyncTexturing::IAsyncTexture& texture);
                
                int TextureCount() const;
                
                int PendingTextureLoadsCount() const;
                
            private:
                Web::IWebLoadRequestFactory& m_webLoadRequestFactory;
                Eegeo::Helpers::IHttpCache& m_httpCache;
                Eegeo::Helpers::ITextureFileLoader& m_textureLoader;
                IAsyncTexture* m_placeholderTexture;
                
                Web::TWebLoadRequestCompletionCallback<HttpAsyncTextureLoader> m_webRequestCompletionCallback;
                Web::PendingWebRequestsContainer m_pendingWebRequestsContainer;

                Helpers::TCallback1<HttpAsyncTextureLoader, const Rendering::AsyncTexturing::AsyncTextureLoadResult> m_asyncTextureLoadCallback;
                Rendering::AsyncTexturing::PendingAsyncTextureLoadsContainer m_pendingAsyncTextureLoadsContainer;
                
                bool Contains(const std::string& textureUrl) const;
              
                HttpAsyncTexture* CreateTexture(const std::string& textureUrl,
                                                IAsyncTextureObserver* pObserver,
                                                bool generateMipmaps,
                                                bool tryToUpdateIfModified);
               
                HttpAsyncTexture* GetTextureByUrl(const std::string& textureUrl) const;
                
                void Evict(HttpAsyncTexture* pTexture);
                
                void StartLoadingTexture(HttpAsyncTexture* pTexture);
                
                void OnTextureWebLoadComplete(Web::IWebResponse& webResponse);

                void OnTextureAsyncLoadComplete(const Rendering::AsyncTexturing::AsyncTextureLoadResult& result);
                
                void BeginLoadTextureFromBuffer(
                    const std::vector<Byte>& buffer,
                    HttpAsyncTexture& texture);

                typedef std::map<HttpAsyncTexture*, Web::IWebLoadRequest*> TTextureToRequest;
                typedef std::deque<HttpAsyncTexture*> TTextureDeque;
                typedef std::map<std::string, HttpAsyncTexture*> TStringToTexture;
                typedef std::map<HttpAsyncTexture*, Rendering::AsyncTexturing::IAsyncTextureLoad*> TTextureToDecode;
                
                TTextureToRequest m_requestByTexture;
                TTextureDeque m_pendingLoads;
                TStringToTexture m_texturesByUrl;
                TTextureToDecode m_decodeByTexture;
                int m_inFlightLoadCount;
                ITextureFactory& m_textureFactory;
            };
        }
    }
}