WorldTextRenderer.h

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

#pragma once

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


namespace Eegeo
{
    namespace Text
    {
        class WorldTextRenderer : public IWorldTextRenderer, private Eegeo::NonCopyable
        {
        public:
            static WorldTextRenderer* Create(Fonts::IFontMaterialSetFactory& fontMaterialSetFactory,
                                             FontMaterialCache& fontMaterialCache,
                                             IBatchedWorldTextRenderableFactory& batchedWorldTextRenderableFactory,
                                             BatchedWorldTextRenderable::VertexBufferType& worldTextVertexBuffer,
                                             bool enableSupersampling);
            
            typedef TBatchedTextRenderableCache<BatchedWorldTextRenderable, IBatchedWorldTextRenderableFactory> BatchedWorldTextRenderableCache;
            
            WorldTextRenderer(TextRendererStateComponent* pTextRendererStateComponent,
                              BatchedWorldTextRenderableCache* pBatchedWorldTextRenderableCache);
            ~WorldTextRenderer();
            
            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 SetModelToWorldTransform(const m44& transform)
            {
                m_modelToWorldTransform = transform;
            }
            
            void DrawShapedGlyph(const ShapedGlyph& shapedGlyph);
            
            void DrawShapedGlyphs(const std::vector<Text::ShapedGlyph>& shapedGlyphs);
            
            void EnqueueRenderables(const Rendering::RenderContext& renderContext, Rendering::RenderQueue& renderQueue);
            
            void Finalize();
            
            void Upload();

            void Reset();
            
        private:

            void SetupRenderables();
            
            void DrawGlyphWorldSpace(const Fonts::FontCharacter& fontCharacter, const v2& shapedTextPos);
            
            TextRendererStateComponent* m_pTextRendererStateComponent;
            
            BatchedWorldTextRenderableCache* m_pBatchedWorldTextRenderableCache;
            
            m44 m_modelToWorldTransform;
        };
    }
}