BatchedTextRenderable.h

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

#pragma once

#include "RenderableBase.h"
#include "Rendering.h"
#include "Fonts.h"
#include "AllVertexTypes.h"
#include "BatchedTextRangeBuilder.h"
#include "GlBuffer.h"

#include <deque>
#include <vector>

namespace Eegeo
{
    namespace Text
    {
        struct BatchedTextRenderableDrawState
        {
            BatchedTextRenderableDrawState();

            const Text::BatchedTextAppearance* pTextAppearance;
            bool IsHaloLayer;
            bool IsStencilMaskPass;
            bool NeedsShaderSetup;
        };
       
        
        class BatchedTextRenderable : public Rendering::RenderableBase
        {
        public:
            static Rendering::SortKey MakeSortKeyForLayer(Rendering::LayerIds::Values layerId, int subLayer, bool isHaloLayer);
            
            static Rendering::SortKey MakeSortKey(const Rendering::Materials::IMaterial& material, const Rendering::SortKey& sortKeyForLayer);
            
            BatchedTextRenderable(Rendering::Materials::IMaterial* pMaterial,
                                  const Rendering::VertexLayouts::VertexBinding* pVertexBinding,
                                  const Rendering::SortKey& sortKey,
                                  int vertexStrideBytes,
                                  const GlBuffer<u16>& quadIndexBuffer
                                  );
            
            ~BatchedTextRenderable();

            virtual void SetTextAppearance(const Text::BatchedTextAppearance& textAppearance);
            
            virtual const Text::BatchedTextAppearance& GetTextAppearanceForCurrentRange() const;
            
            virtual bool ShouldRender() const
            {
                return GetVertexCount() > 0;
            }
            
            virtual void Finalize();
            
            virtual void Upload() = 0;

            virtual void Reset();
            
            bool IsHaloLayer() const
            {
                return m_pDrawState->IsHaloLayer;
            }
            
            bool IsStencilMaskPass() const
            {
                return m_pDrawState->IsStencilMaskPass;
            }
            
            bool NeedsShaderSetup() const
            {
                return m_pDrawState->NeedsShaderSetup;
            }

        protected:
            void Draw(Rendering::GLState& glState, int batchQuadOffset) const;

            virtual int GetVertexCount() const = 0;
            
            virtual const void* GetVertexData(int quadOffset, int quadCount) const = 0;

        private:
            void EndRange(int currentIndexCount) const;
            
            int GetCurrentQuadCount() const;

            Text::BatchedTextRangeBuilder* m_pRangeBuilder;
            
            typedef std::deque<Text::BatchedTextRange> TAppearanceRanges;
            TAppearanceRanges* m_pAppearanceRanges;
            BatchedTextRenderableDrawState* m_pDrawState;
            
            const GlBuffer<u16>& m_quadIndexBuffer;

        };
        
        template <typename TVertex>
        class TBatchedTextRenderable : public BatchedTextRenderable
        {
        public:
            typedef TVertex VertexType;
            typedef TBatchedTextRenderable<TVertex> ThisType;
            typedef std::vector<VertexType> VertexListType;
            typedef GlBuffer<VertexType> VertexBufferType;
            
            TBatchedTextRenderable(Rendering::Materials::IMaterial* pMaterial,
                                   const Rendering::VertexLayouts::VertexBinding* pVertexBinding,
                                   const Rendering::SortKey& sortKey,
                                   const TBatchedTextRenderable* pPrimary,
                                   const GlBuffer<u16>& quadIndexBuffer,
                                   VertexBufferType& vertexBuffer)
            : BatchedTextRenderable(pMaterial, pVertexBinding, sortKey, static_cast<int>(sizeof(VertexType)), quadIndexBuffer)
            , m_pPrimary(pPrimary)
            , m_vertexBuffer(vertexBuffer)
            , m_pVertexList((pPrimary == NULL) ? Eegeo_NEW(VertexListType)() : NULL)
            , m_vertexBufferElementOffset(0)
            {
            }
            
            ~TBatchedTextRenderable()
            {
                Eegeo_DELETE m_pVertexList;
            }
            
            void Upload()
            {
                if (IsPrimary())
                {
                    m_vertexBufferElementOffset = m_vertexBuffer.GetElementOffset();
                    m_vertexBuffer.Upload(*m_pVertexList);
                }
                else
                {
                    m_vertexBufferElementOffset = -1;
                }
            }

            void Reset()
            {
                BatchedTextRenderable::Reset();
                if (m_pVertexList) m_pVertexList->clear();
            }
            
            void Render(Rendering::GLState& glState) const
            {
                const int quadOffset = GetVertexBufferElementOffset() / 4;
                
                m_vertexBuffer.Bind();

                BatchedTextRenderable::Draw(glState, quadOffset);
                
                m_vertexBuffer.Unbind();
                
                if (IsPrimary())
                {
                    m_pVertexList->clear();
                }
            }
            
            VertexListType& GetVertexList() const
            {
                // Replica delegates to its Primary
                return IsPrimary()
                    ? *m_pVertexList
                    : m_pPrimary->GetVertexList();
            }
            
            bool IsPrimary() const
            {
                return m_pPrimary == NULL;
            }
            
            bool IsReplica() const
            {
                return !IsPrimary();
            }
            
        private:

            int GetVertexBufferElementOffset() const
            {
                const int vertexBufferElementOffset = IsPrimary()
                    ? m_vertexBufferElementOffset
                    : m_pPrimary->GetVertexBufferElementOffset();
                
                return vertexBufferElementOffset;
            }
            
            virtual int GetVertexCount() const
            {
                return static_cast<int>(GetVertexList().size());
            }
            
            virtual const void* GetVertexData(int quadOffset, int quadCount) const
            {
                const VertexListType& vertexList = GetVertexList();
                Eegeo_ASSERT((quadOffset+quadCount)*4 <= vertexList.size());
                
                const VertexType* pVertexData = &(vertexList[quadOffset*4]);
                
                return static_cast<const void*>(pVertexData);
            }
            
            const TBatchedTextRenderable* m_pPrimary;
            VertexBufferType& m_vertexBuffer;
            VertexListType* m_pVertexList;
            int m_vertexBufferElementOffset;
            
        };
        
        class BatchedScreenTextRenderable : public TBatchedTextRenderable<Rendering::VertexTypes::ScreenTextVertex>
        {
        public:
            BatchedScreenTextRenderable(Rendering::Materials::IMaterial* pMaterial,
                                        const Rendering::VertexLayouts::VertexBinding* pVertexBinding,
                                        const Rendering::SortKey& sortKey,
                                        const TBatchedTextRenderable* pPrimary,
                                        const GlBuffer<u16>& quadIndexBuffer,
                                        GlBuffer<Rendering::VertexTypes::ScreenTextVertex>& screenTextVertexBuffer
                                        )
            : ThisType::ThisType(pMaterial, pVertexBinding, sortKey, pPrimary, quadIndexBuffer, screenTextVertexBuffer)
            {
                
            }
        };
        
        
        class BatchedWorldTextRenderable : public TBatchedTextRenderable<Rendering::VertexTypes::WorldTextVertex>
        {
        public:
            BatchedWorldTextRenderable(Rendering::Materials::IMaterial* pMaterial,
                                       const Rendering::VertexLayouts::VertexBinding* pVertexBinding,
                                       const Rendering::SortKey& sortKey,
                                       const TBatchedTextRenderable* pPrimary,
                                       const GlBuffer<u16>& quadIndexBuffer,
                                       GlBuffer<Rendering::VertexTypes::WorldTextVertex>& worldTextVertexBuffer
                                       )
            : ThisType::ThisType(pMaterial, pVertexBinding, sortKey, pPrimary, quadIndexBuffer, worldTextVertexBuffer)
            {
                
            }
        };
    }
}