BatchedTextRenderableCache.h

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

#pragma once

#include "Text.h"
#include "Types.h"
#include "IdTypes.h"
#include "Fonts.h"
#include "Rendering.h"
#include "VectorMath.h"
#include "BatchedTextRenderable.h"

#include "IBatchedTextRenderableFactory.h"
#include "ITextMaterialFactory.h"
#include "FontInstance.h"
#include "FontCharacter.h"
#include "FontMaterialSetBuilder.h"
#include "FontMaterialSet.h"

#include <string>
#include <vector>
#include <map>



namespace Eegeo
{
    namespace Text
    {
        template <typename TBatchedTextRenderable, typename TBatchedTextRenderableFactory>
        class TBatchedTextRenderableCache : private Eegeo::NonCopyable
        {
        public:
            typedef TBatchedTextRenderable BatchedTextRenderableType;
            typedef TBatchedTextRenderableFactory BatchedTextRenderableFactoryType;
            typedef TBatchedTextRenderableCache<TBatchedTextRenderable, TBatchedTextRenderableFactory> ThisType;
            typedef typename BatchedTextRenderableType::VertexBufferType VertexBufferType;
        private:
            typedef std::pair<Rendering::SortKey, Rendering::SortKey> SortKeyPair;
            typedef std::map<SortKeyPair, BatchedTextRenderableType*> TSortKeyToTextRenderable;
            
        public:
            
            typedef typename TSortKeyToTextRenderable::const_iterator TextRenderableIterator;
            
            TBatchedTextRenderableCache(
                                       TBatchedTextRenderableFactory& batchedTextRenderableFactory,
                                       VertexBufferType& vertexBuffer)
            : m_batchedTextRenderableFactory(batchedTextRenderableFactory)
            , m_vertexBuffer(vertexBuffer)
            {}
            
            ~TBatchedTextRenderableCache()
            {
                for (typename TSortKeyToTextRenderable::const_iterator iter = m_sortKeyToTextRenderable.begin(); iter != m_sortKeyToTextRenderable.end(); ++iter)
                {
                    BatchedTextRenderable* pTextRenderable = iter->second;
                    Eegeo_DELETE pTextRenderable;
                }
            }
            
            void SetupCurrentFont(const Fonts::FontMaterialSet& fontMaterialSetNonHalo, const Fonts::FontMaterialSet& fontMaterialSetHalo, Rendering::LayerIds::Values layerId, int subLayer)
            {
                const Fonts::FontMaterialSet::TMaterialVector& foregroundMaterials = fontMaterialSetNonHalo.GetMaterials();
                const Fonts::FontMaterialSet::TMaterialVector& haloMaterials = fontMaterialSetHalo.GetMaterials();
                Eegeo_ASSERT(foregroundMaterials.size() == haloMaterials.size());

                m_foregroundLayerTextRenderables.clear();
                m_foregroundLayerTextRenderables.reserve(foregroundMaterials.size());
                m_haloLayerTextRenderables.clear();
                m_haloLayerTextRenderables.reserve(haloMaterials.size());
                
                const Rendering::SortKey& sortKeyForegroundLayer = BatchedTextRenderable::MakeSortKeyForLayer(layerId, subLayer, false);
                const Rendering::SortKey& sortKeyHaloLayer = BatchedTextRenderable::MakeSortKeyForLayer(layerId, subLayer, true);

                for (int i = 0; i < foregroundMaterials.size(); ++i)
                {
                    Rendering::Materials::IMaterial& foregroundMaterial = *foregroundMaterials.at(i);
                    const Rendering::SortKey& sortKeyForeground = BatchedTextRenderable::MakeSortKey(foregroundMaterial, sortKeyForegroundLayer);
                    BatchedTextRenderableType* pForegroundBatchedTextRenderable = GetRenderableForSortKeyOrNull(sortKeyForeground, Rendering::SortKey());
                    if (pForegroundBatchedTextRenderable == NULL)
                    {
                        pForegroundBatchedTextRenderable = CreateAndAddRenderable(sortKeyForeground, foregroundMaterial, NULL);
                    }
                    m_foregroundLayerTextRenderables.push_back(pForegroundBatchedTextRenderable);
                    
                    
                    Rendering::Materials::IMaterial& haloMaterial = *haloMaterials.at(i);
                    const Rendering::SortKey& sortKeyHalo = BatchedTextRenderable::MakeSortKey(haloMaterial, sortKeyHaloLayer);
                    BatchedTextRenderableType* pHaloBatchedTextRenderable = GetRenderableForSortKeyOrNull(sortKeyHalo, sortKeyForeground);
                    if (pHaloBatchedTextRenderable == NULL)
                    {
                        pHaloBatchedTextRenderable = CreateAndAddRenderable(sortKeyHalo, haloMaterial, pForegroundBatchedTextRenderable);
                    }
                    m_haloLayerTextRenderables.push_back(pHaloBatchedTextRenderable);
                }
            }
            
            void ClearCurrentFont()
            {
                m_foregroundLayerTextRenderables.clear();
                m_haloLayerTextRenderables.clear();
            }
            
            typename BatchedTextRenderableType::VertexListType& GetTextVertexList(int texturePage) const
            {
                return m_foregroundLayerTextRenderables[texturePage]->GetVertexList();
            }
            
            void UpdateTextAppearanceOnCurrentRenderables(const BatchedTextAppearance& batchedTextAppearance)
            {
                UpdateTextAppearanceOnRenderables(batchedTextAppearance, m_foregroundLayerTextRenderables);
                UpdateTextAppearanceOnRenderables(batchedTextAppearance, m_haloLayerTextRenderables);
            }
            
            
            TextRenderableIterator TextRenderablesBegin() const { return m_sortKeyToTextRenderable.begin(); }
            TextRenderableIterator TextRenderablesEnd() const { return m_sortKeyToTextRenderable.end(); }
            
            void Reset()
            {
                m_vertexBuffer.Reset();

                for (TextRenderableIterator iter = TextRenderablesBegin(); iter != TextRenderablesEnd(); ++iter)
                {
                    BatchedTextRenderableType& textRenderable = *(iter->second);
                    textRenderable.Reset();
                }
            }

            void Finalize()
            {
                m_vertexBuffer.Swap();
                m_vertexBuffer.Reset();
                
                int totalVertexCount = 0;
                for (TextRenderableIterator iter = TextRenderablesBegin(); iter != TextRenderablesEnd(); ++iter)
                {
                    BatchedTextRenderableType& textRenderable = *(iter->second);
                    textRenderable.Finalize();
                    
                    if (textRenderable.IsPrimary())
                    {
                        totalVertexCount += static_cast<int>(textRenderable.GetVertexList().size());
                    }
                }
                
                m_vertexBuffer.Reserve(totalVertexCount);
            }
            
            void Upload()
            {
                m_vertexBuffer.Bind();
                
                for (TextRenderableIterator iter = TextRenderablesBegin(); iter != TextRenderablesEnd(); ++iter)
                {
                    BatchedTextRenderableType& textRenderable = *(iter->second);
                    textRenderable.Upload();
                }
                
                m_vertexBuffer.Unbind();
            }
            
        private:
        
        
            void UpdateTextAppearanceOnRenderables(const BatchedTextAppearance& batchedTextAppearance, typename std::vector<TBatchedTextRenderable*>& renderables)
            {
                for (typename std::vector<TBatchedTextRenderable*>::const_iterator iter = renderables.begin(); iter != renderables.end(); ++iter)
                {
                    BatchedTextRenderable* pTextRenderable = *iter;
                    pTextRenderable->SetTextAppearance(batchedTextAppearance);
                }
            }
            

            BatchedTextRenderableType* GetRenderableForSortKeyOrNull(const Rendering::SortKey& sortKey, const Rendering::SortKey& sortKeyPrimary)
            {
                typename TSortKeyToTextRenderable::const_iterator iter = m_sortKeyToTextRenderable.find(std::make_pair(sortKey, sortKeyPrimary));
                
                if (iter == m_sortKeyToTextRenderable.end())
                {
                    return NULL;
                }

                return iter->second;
            }
            
            BatchedTextRenderableType* CreateAndAddRenderable(const Rendering::SortKey& sortKey, Rendering::Materials::IMaterial& material, BatchedTextRenderableType* pPrimaryRenderable)
            {
                BatchedTextRenderableType* pBatchedTextRenderableType = m_batchedTextRenderableFactory.Create(material, sortKey, pPrimaryRenderable);
                
                const Rendering::SortKey& sortKeyPrimary = (pPrimaryRenderable != NULL) ? pPrimaryRenderable->GetSortKey() : Rendering::SortKey();
                
                const SortKeyPair sortKeyPair(std::make_pair(sortKey, sortKeyPrimary));
                
                m_sortKeyToTextRenderable.insert(std::make_pair(sortKeyPair, pBatchedTextRenderableType));
                return pBatchedTextRenderableType;
            }

            
            TBatchedTextRenderableFactory& m_batchedTextRenderableFactory;
            VertexBufferType& m_vertexBuffer;

            std::vector<TBatchedTextRenderable*> m_foregroundLayerTextRenderables;
            std::vector<TBatchedTextRenderable*> m_haloLayerTextRenderables;

            TSortKeyToTextRenderable m_sortKeyToTextRenderable;
            
            
        };

    }
}