BatchedIconRenderableCache.h

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

#pragma once

#include "Types.h"
#include "BatchedIconAppearance.h"
#include "BatchedIconRenderable.h"
#include "SortKey.h"
#include "IBatchedIconRenderableFactory.h"
#include <map>
#include <vector>

namespace Eegeo
{
    namespace Icons
    {
        template <typename TBatchedIconRenderable, typename TBatchedIconRenderableFactory>
        class TBatchedIconRenderableCache : private Eegeo::NonCopyable
        {
        public:
            typedef TBatchedIconRenderable BatchedIconRenderableType;
            typedef TBatchedIconRenderableFactory BatchedIconRenderableFactoryType;
            typedef TBatchedIconRenderableCache<TBatchedIconRenderable, TBatchedIconRenderableFactory> ThisType;
            typedef typename BatchedIconRenderableType::VertexBufferType VertexBufferType;
        private:
            
            typedef std::map<Rendering::SortKey, BatchedIconRenderableType*> TSortKeyToIconRenderable;
            
        public:
            
            typedef typename TSortKeyToIconRenderable::const_iterator IconRenderableIterator;
            
            TBatchedIconRenderableCache(
                                        TBatchedIconRenderableFactory& batchedIconRenderableFactory,
                                        VertexBufferType& vertexBuffer)
            : m_batchedIconRenderableFactory(batchedIconRenderableFactory)
            , m_vertexBuffer(vertexBuffer)
            {}
            
            ~TBatchedIconRenderableCache()
            {
                for (typename TSortKeyToIconRenderable::const_iterator iter = m_sortKeyToIconRenderable.begin(); iter != m_sortKeyToIconRenderable.end(); ++iter)
                {
                    BatchedIconRenderable* pIconRenderable = iter->second;
                    Eegeo_DELETE pIconRenderable;
                }
            }
            
            void SetupCurrentIconSet(const std::vector<Rendering::Materials::IMaterial*>& materialSet, Rendering::LayerIds::Values layerId, int subLayer)
            {
                m_iconRenderables.clear();
                m_iconRenderables.reserve(materialSet.size());
                
                for (std::vector<Rendering::Materials::IMaterial*>::const_iterator materialIter = materialSet.begin(); materialIter != materialSet.end(); ++materialIter)
                {
                    Rendering::Materials::IMaterial& material = **materialIter;
                    
                    BatchedIconRenderableType* pBatchedTextRenderable = GetRenderableForMaterial(material, layerId, subLayer, NULL);
                    m_iconRenderables.push_back(pBatchedTextRenderable);
                }
            }
            
            void ClearCurrentIconSet()
            {
                m_iconRenderables.clear();
            }
            
            typename BatchedIconRenderableType::VertexListType& GetVertexList(int texturePage) const
            {
                return m_iconRenderables[texturePage]->GetVertexList();
            }
            
            void UpdateIconAppearanceOnCurrentRenderables(const BatchedIconAppearance& batchedAppearance)
            {
                UpdateAppearanceOnRenderables(batchedAppearance, m_iconRenderables);
            }
            
            
            IconRenderableIterator RenderablesBegin() const { return m_sortKeyToIconRenderable.begin(); }
            IconRenderableIterator RenderablesEnd() const { return m_sortKeyToIconRenderable.end(); }
            
            void Finalize()
            {
                m_vertexBuffer.Reset();
                
                int totalVertexCount = 0;
                for (IconRenderableIterator iter = RenderablesBegin(); iter != RenderablesEnd(); ++iter)
                {
                    BatchedIconRenderableType& renderable = *(iter->second);
                    renderable.Finalize();
                    
                    if (renderable.IsPrimary())
                    {
                        totalVertexCount += renderable.GetVertexList().size();
                    }
                }
                
                m_vertexBuffer.Reserve(totalVertexCount);
            }
            
            void Upload()
            {
                m_vertexBuffer.Bind();
                
                for (IconRenderableIterator iter = RenderablesBegin(); iter != RenderablesEnd(); ++iter)
                {
                    BatchedIconRenderableType& renderable = *(iter->second);
                    renderable.Upload();
                }
                
                m_vertexBuffer.Unbind();
            }
            
        private:
            
            
            void UpdateAppearanceOnRenderables(const BatchedIconAppearance& batchedAppearance, typename std::vector<TBatchedIconRenderable*>& renderables)
            {
                for (typename std::vector<TBatchedIconRenderable*>::const_iterator iter = renderables.begin(); iter != renderables.end(); ++iter)
                {
                    BatchedIconRenderable* pRenderable = *iter;
                    pRenderable->SetAppearance(batchedAppearance);
                }
            }
            
            
            BatchedIconRenderableType* GetRenderableForMaterial(Rendering::Materials::IMaterial& material, Rendering::LayerIds::Values layerId, int subLayer, BatchedIconRenderableType* pPrimaryRenderable)
            {
                const Rendering::SortKey& sortKey = BatchedIconRenderable::MakeSortKey(material, layerId, subLayer);
                
                typename TSortKeyToIconRenderable::const_iterator iter = m_sortKeyToIconRenderable.find(sortKey);
                
                if (iter == m_sortKeyToIconRenderable.end())
                {
                    m_sortKeyToIconRenderable.insert(std::make_pair(sortKey, m_batchedIconRenderableFactory.Create(material, sortKey, pPrimaryRenderable)));
                    iter = m_sortKeyToIconRenderable.find(sortKey);
                }
                
                BatchedIconRenderableType* pBatchedIconRenderable = iter->second;
                Eegeo_ASSERT(pBatchedIconRenderable->GetLayer() == layerId);
                Eegeo_ASSERT(pBatchedIconRenderable->GetUserDefined() == subLayer);
                return pBatchedIconRenderable;
            }
            
            
            TBatchedIconRenderableFactory& m_batchedIconRenderableFactory;
            VertexBufferType& m_vertexBuffer;
            
            std::vector<TBatchedIconRenderable*> m_iconRenderables;
            
            TSortKeyToIconRenderable m_sortKeyToIconRenderable;
            
            
        };
    }
}