ScreenTextRenderer.h

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

#pragma once

#include "Types.h"
#include "IScreenTextRenderer.h"
#include "Fonts.h"
#include "Text.h"
#include "TextRendererStateComponent.h"
#include "BatchedTextRenderable.h"


namespace Eegeo
{
    namespace Text
    {
        class ScreenTextRenderer : public IScreenTextRenderer, private Eegeo::NonCopyable
        {
        public:
            static ScreenTextRenderer* Create(Fonts::IFontMaterialSetFactory& fontMaterialSetFactory,
                                              FontMaterialCache& fontMaterialCache,
                                              IBatchedScreenTextRenderableFactory& batchedScreenTextRenderableFactory,
                                              BatchedScreenTextRenderable::VertexBufferType& screenTextVertexBuffer,
                                              bool enableSupersampling);
            
            typedef TBatchedTextRenderableCache<BatchedScreenTextRenderable, IBatchedScreenTextRenderableFactory> BatchedScreenTextRenderableCache;
            
            ScreenTextRenderer(TextRendererStateComponent* pTextRendererStateComponent,
                               BatchedScreenTextRenderableCache* pBatchedScreenTextRenderableCache);
            ~ScreenTextRenderer();
            
            void SetFontInstance(const Fonts::FontInstance* pFontInstance)
            {
                m_pTextRendererStateComponent->SetFontInstance(pFontInstance);
            }
            
            void SetDefaultState();
            
            void SetTextSize(float pixelHeight)
            {
                m_pTextRendererStateComponent->SetTextSize(pixelHeight);
            }
            
            void SetGlyphColor(const v4& color)
            {
                m_pTextRendererStateComponent->SetGlyphColor(color);
            }
            
            void SetOutlineColor(const v4& color)
            {
                m_pTextRendererStateComponent->SetOutlineColor(color);
            }
            
            void SetHaloStyle(const v4& color, float haloWidth, float haloHardness)
            {
                m_pTextRendererStateComponent->SetHaloStyle(color, haloWidth, haloHardness);
            }
            
            void SetTransform(const v2& translate, const v2& rotate, const v2& scale)
            {
                m_pTextRendererStateComponent->SetTransform(translate, rotate, scale);
            }
            
            void SetDepthTest(bool depthTest)
            {
                m_pTextRendererStateComponent->SetDepthTest(depthTest);
            }
            
            void SetStencilTest(bool stencilTest)
            {
                m_pTextRendererStateComponent->SetStencilTest(stencilTest);
            }
            
            void SetStencilFunc(GLenum stencilFunc, int stencilRef, u32 stencilMask)
            {
                m_pTextRendererStateComponent->SetStencilFunc(stencilFunc, stencilRef, stencilMask);
            }
            
            void SetStencilMaskedStyle(bool enable, GLenum stencilFunc, const v4& glyphColor, const v4& haloColor)
            {
                m_pTextRendererStateComponent->SetStencilMaskedStyle(enable, stencilFunc, glyphColor, haloColor);
            }
            
            void SetRenderLayer(Rendering::LayerIds::Values layer, int subLayer)
            {
                m_pTextRendererStateComponent->SetRenderLayer(layer, subLayer);
            }
            
            void SetAlpha(float alpha)
            {
                m_pTextRendererStateComponent->SetAlpha(alpha);
            }
            
            void DrawShapedGlyph(const ShapedGlyph& shapedGlyph);
            
            void DrawShapedGlyphs(const std::vector<Text::ShapedGlyph>& shapedGlyphs);

            void Finalize();
            
            void Upload();

            void EnqueueRenderables(const Rendering::RenderContext& renderContext, Rendering::RenderQueue& renderQueue);

            void Reset();
            
        private:
            void SetupRenderables();

            TextRendererStateComponent* m_pTextRendererStateComponent;
            
            BatchedScreenTextRenderableCache* m_pBatchedScreenTextRenderableCache;

        };
    }
}