TextRendererStateComponent.h

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

#pragma once

#include "Types.h"
#include "IScreenTextRenderer.h"
#include "DebugRendering.h"
#include "IdTypes.h"
#include "Fonts.h"
#include "BatchedTextAppearanceBuilder.h"
#include "Text.h"
#include "FontInstance.h"
#include "LayerIds.h"
#include "FontMaterialSetProperties.h"

namespace Eegeo
{
    namespace Text
    {
        class TextRendererStateComponent : private Eegeo::NonCopyable
        {
        public:
            TextRendererStateComponent(Fonts::IFontMaterialSetFactory& fontMaterialSetFactory,
                                       FontMaterialCache& fontMaterialCache,
                                       bool enableSupersampling,
                                       bool uniformScale
                                       );
            
            void SetFontInstance(const Fonts::FontInstance* pFontInstance)
            {
                m_fontInstanceChanged = m_pFontInstance != pFontInstance;
                m_pFontInstance = pFontInstance;
            }
            
            void SetDefaultState();
            
            void SetTextSize(float pixelHeight)
            {
                m_textAppearanceBuilder.SetSize(pixelHeight);
                m_textAppearanceChanged = true;
                if (m_pFontInstance != NULL)
                {
                    const bool prevMinifying = m_batchedTextAppearance.GetSize() < m_pFontInstance->GetHeight();
                    const bool minifying = pixelHeight < m_pFontInstance->GetHeight();
                    m_minificationChanged = minifying != prevMinifying;
                }
            }
            
            void SetGlyphColor(const v4& color)
            {
                m_textAppearanceBuilder.SetGlyphColor(color);
                m_textAppearanceChanged = true;
            }
            
            void SetOutlineColor(const v4& color)
            {
                m_textAppearanceBuilder.SetOutlineColor(color);
                m_textAppearanceChanged = true;
            }
            
            void SetHaloStyle(const v4& color, float haloWidth, float haloHardness)
            {
                m_textAppearanceBuilder.SetHaloColor(color);
                m_textAppearanceBuilder.SetHaloWidth(haloWidth);
                m_textAppearanceBuilder.SetHaloHardness(haloHardness);
                m_textAppearanceChanged = true;
            }
            
            void SetTransform(const v2& translate, const v2& rotate, const v2& scale)
            {
                m_translate = translate;
                m_rotate = rotate;
                m_scale = scale;
            }
            
            void SetDepthTest(bool depthTest)
            {
                m_textAppearanceBuilder.SetDepthTest(depthTest);
                m_textAppearanceChanged = true;
            }
            
            void SetStencilTest(bool stencilTest)
            {
                m_textAppearanceBuilder.SetStencilTest(stencilTest);
                m_textAppearanceChanged = true;
            }
            
            void SetStencilFunc(GLenum stencilFunc, int stencilRef, u32 stencilMask)
            {
                m_textAppearanceBuilder.SetStencilFunc(stencilFunc, stencilRef, stencilMask);
                m_textAppearanceChanged = true;
            }
            
            void SetStencilMaskedStyle(bool enable, GLenum stencilFunc, const v4& glyphColor, const v4& haloColor)
            {
                m_textAppearanceBuilder.SetStencilMaskedStyle(enable, stencilFunc, glyphColor, haloColor);
                m_textAppearanceChanged = true;
            }
            
            void SetRenderLayer(Rendering::LayerIds::Values layer, int subLayer)
            {
                m_layerChanged = m_layer != layer || m_subLayer != subLayer;
                m_layer = layer;
                m_subLayer = subLayer;
            }
            
            void SetAlpha(float alpha)
            {
                m_alpha = alpha;
            }
            
            v2 GetTranslate() const { return m_translate; }
            v2 GetRotate() const { return m_rotate; }
            v2 GetScale() const { return m_scale; }
            float GetAlpha() const { return m_alpha; }
            
            Rendering::LayerIds::Values GetLayer() const { return m_layer; }
            int GetSubLayer() const { return m_subLayer; }
            
            
            bool NeedsCachedStateUpdate() const { return m_textAppearanceChanged || m_fontInstanceChanged || m_minificationChanged || m_layerChanged; }
            
            bool NeedsRenderableSetup() const { return m_fontInstanceChanged || m_minificationChanged || m_layerChanged; }

           
            void UpdateCachedState();
            
            const Fonts::FontInstance* GetFontInstance() const { return m_pFontInstance; }
            
            const Fonts::FontMaterialSet* GetFontMaterialSetForeground() const { return m_pFontMaterialSetForeground; }
            
            const Fonts::FontMaterialSet* GetFontMaterialSetHalo() const { return m_pFontMaterialSetHalo; }
            
            const Text::BatchedTextAppearance& GetBatchedTextAppearance() const { return m_batchedTextAppearance; }
            
            const Fonts::FontCharacter& GetFontCharacter(u32 codepointUtf32) { return m_pFontInstance->GetCharacter(codepointUtf32); }
            
        private:
            Fonts::FontMaterialSet* GetFontMaterialSetForFontInstance(const Fonts::FontInstance& fontInstance);
            
            Fonts::FontMaterialSet* CreateFontMaterialSet(const Fonts::FontInstance& fontInstance);
            
            Fonts::IFontMaterialSetFactory& m_fontMaterialSetFactory;
            FontMaterialCache& m_fontMaterialCache;
            
            Text::BatchedTextAppearanceBuilder m_textAppearanceBuilder;
            Text::BatchedTextAppearance m_batchedTextAppearance;
            
            const Fonts::FontInstance* m_pFontInstance;
            const Fonts::FontMaterialSet* m_pFontMaterialSetForeground;
            const Fonts::FontMaterialSet* m_pFontMaterialSetHalo;
            
            v2 m_translate;
            v2 m_rotate;
            v2 m_scale;
            float m_alpha;
            Rendering::LayerIds::Values m_layer;
            int m_subLayer;
            
            bool m_textAppearanceChanged;
            bool m_fontInstanceChanged;
            bool m_minificationChanged;
            bool m_layerChanged;
            const bool m_enableSupersampling;
            const bool m_uniformScale;
        };
    }
}