HttpAsyncCubeTextureLoader.h

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

#pragma once

#include "Types.h"
#include "IAsyncCubeTextureRequestor.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
        {
            class HttpAsyncCubeTextureLoader : protected Eegeo::NonCopyable, public IAsyncCubeTextureRequestor
            {
            public:
                HttpAsyncCubeTextureLoader(Web::IWebLoadRequestFactory& webLoadRequestFactory,
                                           Eegeo::Helpers::IHttpCache& httpCache,
                                           Eegeo::Helpers::ITextureFileLoader& textureLoader,
                                           IAsyncTexture& placeholderTexture);

                ~HttpAsyncCubeTextureLoader();
                
                IAsyncTexture& RequestCubeTexture(const Helpers::CubeTextureName& cubeTextureName,
                                                  IAsyncTextureObserver* pObserver,
                                                  bool tryToUpdateIfModified=false);
                
                void Release(const HttpAsyncCubeTexture& textureToRelease);
                void DestroyTexture(const HttpAsyncCubeTexture& textureToRelease);
                
                void IssueNextLoadRequest();
                bool HasPendingLoadRequests() const;
                
                int CubeTextureCount() const;
                
                int PendingCubeTextureLoadsCount() const;
                
            private:
                Web::IWebLoadRequestFactory& m_webLoadRequestFactory;
                Eegeo::Helpers::IHttpCache& m_httpCache;
                Eegeo::Helpers::ITextureFileLoader& m_textureLoader;
                IAsyncTexture* m_placeholderTexture;
                
                Web::TWebLoadRequestCompletionCallback<HttpAsyncCubeTextureLoader> m_cubeWebRequestCompletionCallback;
                Web::PendingWebRequestsContainer m_pendingCubeWebRequestsContainer;

                Helpers::TCallback1<HttpAsyncCubeTextureLoader, const Rendering::AsyncTexturing::AsyncTextureLoadResult> m_asyncTextureLoadCallback;
                Rendering::AsyncTexturing::PendingAsyncTextureLoadsContainer m_pendingAsyncTextureLoadsContainer;
                
                
                bool Contains(const std::string& textureUrl) const;
              
                HttpAsyncCubeTexture* CreateTexture(const Helpers::CubeTextureName& cubeTextureName,
                                                    IAsyncTextureObserver* pObserver,
                                                    bool tryToUpdateIfModified);
               
                HttpAsyncCubeTexture* GetCubeTextureByUrl(const std::string& textureUrl) const;
                
                void Evict(HttpAsyncCubeTexture* textureToRelease);

                void StartLoadingTexture(HttpAsyncCubeTexture* pTexture);

                bool TryAttachTextureBufferFromCache(HttpAsyncCubeTexture* pTexture, int faceIndex, const std::string& url);

                void CreateTextureFileRequest(HttpAsyncCubeTexture* pTexture, int faceIndex, const std::string& url, std::vector<Web::IWebLoadRequest*> &requestsToIssue);

                void OnCubeTextureWebLoadComplete(Web::IWebResponse& webResponse);
                
                void BeginLoadCubeTextureFromBuffers(
                    const std::vector<const std::vector<Byte>*>& cubeFaceBuffers,
                    HttpAsyncCubeTexture& texture);

                void OnCubeTextureAsyncLoadComplete(const Rendering::AsyncTexturing::AsyncTextureLoadResult& result);
                
                void AbandonLoads(HttpAsyncCubeTexture* pTexture);
                
                typedef std::map<HttpAsyncCubeTexture*, std::vector<Web::IWebLoadRequest*> > TCubeTextureToRequests;
                typedef std::deque<HttpAsyncCubeTexture*> TCubeTextureDeque;
                typedef std::map<std::string, HttpAsyncCubeTexture*> TStringToCubeTexture;
                
                TCubeTextureToRequests m_requestsByCubeTexture;
                TCubeTextureDeque m_pendingCubeLoads;
                TStringToCubeTexture m_cubeTexturesByUrl;
                int m_inFlightCubeLoadCount;
            };
        }
    }
}