BatchedIconRenderable.h

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

#pragma once

#include "RenderableBase.h"
#include "Rendering.h"
#include "SortKey.h"
#include "Types.h"
#include "GlBuffer.h"

#include "BatchedIconAppearance.h"
#include "BatchedIconRangeBuilder.h"

#include "AllVertexTypes.h"

#include <deque>

namespace Eegeo
{
    namespace Icons
    {
        struct BatchedIconRenderableDrawState
        {
            BatchedIconRenderableDrawState();
            
            const BatchedIconAppearance* pAppearance;
            bool IsStencilMaskPass;
            bool NeedsShaderSetup;
        };
        
        
        // TODO: This looks pretty general.
        class BatchedIconRenderable : public Rendering::RenderableBase
        {
        public:
            static Rendering::SortKey MakeSortKey(const Rendering::Materials::IMaterial& material,
                                                  Rendering::LayerIds::Values layerId,
                                                  int subLayer);
            
            BatchedIconRenderable(Rendering::Materials::IMaterial* pMaterial,
                                   const Rendering::VertexLayouts::VertexBinding* pVertexBinding,
                                   const Rendering::SortKey& sortKey,
                                   int vertexStrideBytes,
                                   const Text::GlBuffer<u16>& quadIndexBuffer
                                  );
            
            ~BatchedIconRenderable();
            
            virtual void SetAppearance(const BatchedIconAppearance& appearance);
            
            virtual const BatchedIconAppearance& GetAppearanceForCurrentRange() const;
            
            virtual bool ShouldRender() const
            {
                return GetVertexCount() > 0;
            }
            
            virtual void Finalize();
            
            virtual void Upload() = 0;

            virtual void Reset() = 0;
            
            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;
            
            BatchedIconRangeBuilder* m_pRangeBuilder;
            
            typedef std::deque<BatchedIconRange> TAppearanceRanges;
            TAppearanceRanges* m_pAppearanceRanges;
            BatchedIconRenderableDrawState* m_pDrawState;
            
            const Text::GlBuffer<u16>& m_quadIndexBuffer;
            
        };
        
        // TODO: Everything below this line is pretty much a direct copy of TBatchedTextRenderable - Unify batched quad rendering!
        
        template <typename TVertex>
        class TBatchedIconRenderable : public BatchedIconRenderable
        {
        public:
            typedef TVertex VertexType;
            typedef TBatchedIconRenderable<TVertex> ThisType;
            typedef std::vector<VertexType> VertexListType;
            typedef Text::GlBuffer<VertexType> VertexBufferType;
            
            TBatchedIconRenderable(Rendering::Materials::IMaterial* pMaterial,
                                    const Rendering::VertexLayouts::VertexBinding* pVertexBinding,
                                    const Rendering::SortKey& sortKey,
                                    const TBatchedIconRenderable* pPrimary,
                                    const Text::GlBuffer<u16>& quadIndexBuffer,
                                    VertexBufferType& vertexBuffer)
            : BatchedIconRenderable(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)
            {
            }
            
            ~TBatchedIconRenderable()
            {
                Eegeo_DELETE m_pVertexList;
            }
            
            void Upload()
            {
                if (IsPrimary())
                {
                    m_vertexBufferElementOffset = m_vertexBuffer.GetElementOffset();
                    m_vertexBuffer.Upload(*m_pVertexList);
                }
                else
                {
                    m_vertexBufferElementOffset = -1;
                }
            }
            
            void Render(Rendering::GLState& glState) const
            {
                const int quadOffset = GetVertexBufferElementOffset() / 4;
                
                m_vertexBuffer.Bind();
                
                BatchedIconRenderable::Draw(glState, quadOffset);
                
                m_vertexBuffer.Unbind();
                
                if (IsPrimary())
                {
                    m_pVertexList->clear();
                }
            }

            void Reset()
            {
                if (m_pVertexList)
                {
                    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 TBatchedIconRenderable* m_pPrimary;
            VertexBufferType& m_vertexBuffer;
            VertexListType* m_pVertexList;
            int m_vertexBufferElementOffset;
            
        };
        
        class BatchedScreenIconRenderable : public TBatchedIconRenderable<Rendering::VertexTypes::ScreenTextVertex>
        {
        public:
            BatchedScreenIconRenderable(Rendering::Materials::IMaterial* pMaterial,
                                        const Rendering::VertexLayouts::VertexBinding* pVertexBinding,
                                        const Rendering::SortKey& sortKey,
                                        const TBatchedIconRenderable* pPrimary,
                                        const Text::GlBuffer<u16>& quadIndexBuffer,
                                        Text::GlBuffer<Rendering::VertexTypes::ScreenTextVertex>& screenTextVertexBuffer
                                        )
            : ThisType::ThisType(pMaterial, pVertexBinding, sortKey, pPrimary, quadIndexBuffer, screenTextVertexBuffer)
            {
                
            }
        };
        
        
        class BatchedWorldIconRenderable : public TBatchedIconRenderable<Rendering::VertexTypes::WorldTextVertex>
        {
        public:
            BatchedWorldIconRenderable(Rendering::Materials::IMaterial* pMaterial,
                                       const Rendering::VertexLayouts::VertexBinding* pVertexBinding,
                                       const Rendering::SortKey& sortKey,
                                       const TBatchedIconRenderable* pPrimary,
                                       const Text::GlBuffer<u16>& quadIndexBuffer,
                                       Text::GlBuffer<Rendering::VertexTypes::WorldTextVertex>& worldTextVertexBuffer
                                       )
            : ThisType::ThisType(pMaterial, pVertexBinding, sortKey, pPrimary, quadIndexBuffer, worldTextVertexBuffer)
            {
                
            }
        };
    }
}