WorldIconRenderer.h

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

#pragma once

#include "IWorldIconRenderer.h"
#include "Types.h"
#include "Icons.h"
#include "BatchedIconRenderable.h"
#include "IconRendererStateComponent.h"

namespace Eegeo
{
    namespace Icons
    {
        class WorldIconRenderer : public IWorldIconRenderer, private Eegeo::NonCopyable
        {
        public:
            static WorldIconRenderer* Create(IconMaterialSetFactory& iconMaterialSetFactory,
                                             IconMaterialSetCache& iconMaterialSetCache,
                                             IBatchedWorldIconRenderableFactory& batchedWorldIconRenderableFactory,
                                             BatchedWorldIconRenderable::VertexBufferType& worldIconVertexBuffer);
            
            typedef TBatchedIconRenderableCache<BatchedWorldIconRenderable, IBatchedWorldIconRenderableFactory> BatchedWorldIconRenderableCache;
            
            WorldIconRenderer(IconRendererStateComponent* pTextRendererStateComponent,
                              BatchedWorldIconRenderableCache* pBatchedWorldIconRenderableCache);
            ~WorldIconRenderer();
            
            void SetIconSet(const IconSet* pIconSet)
            {
                m_pIconRendererStateComponent->SetIconSet(pIconSet);
            }
            
            void SetDefaultState();
            
            void SetIconColor(const v4& iconColor)
            {
                m_pIconRendererStateComponent->SetIconColor(iconColor);
            }
            
            void SetIconScale(float iconScale)
            {
                m_pIconRendererStateComponent->SetScale(iconScale);
            }
            
            void SetTransform(const v2& translate, const v2& rotate, const v2& scale)
            {
                m_pIconRendererStateComponent->SetTransform(translate, rotate, scale);
            }
            
            void SetDepthTest(bool depthTest)
            {
                m_pIconRendererStateComponent->SetDepthTest(depthTest);
            }
            
            void SetStencilTest(bool stencilTest)
            {
                m_pIconRendererStateComponent->SetStencilTest(stencilTest);
            }
            
            void SetStencilFunc(GLenum stencilFunc, int stencilRef, u32 stencilMask)
            {
                m_pIconRendererStateComponent->SetStencilFunc(stencilFunc, stencilRef, stencilMask);
            }
            
            void SetStencilMaskedStyle(bool enable, GLenum stencilFunc, const v4& iconColor)
            {
                m_pIconRendererStateComponent->SetStencilMaskedStyle(enable, stencilFunc, iconColor);
            }
            
            void SetRenderLayer(Rendering::LayerIds::Values layer, int subLayer)
            {
                m_pIconRendererStateComponent->SetRenderLayer(layer, subLayer);
            }
            
            void SetAlpha(float alpha)
            {
                m_pIconRendererStateComponent->SetAlpha(alpha);
            }
            
            void SetModelToWorldTransform(const m44& transform)
            {
                m_modelToWorldTransform = transform;
            }
            
            void DrawIcon(const IconDefinition& shapedIcon);
            
            void DrawIcons(const std::vector<const IconDefinition*>& shapedIcons);
            
            void Finalize();
            
            void Upload();
            
            void EnqueueRenderables(const Rendering::RenderContext& renderContext, Rendering::RenderQueue& renderQueue);
            
        private:
            void SetupRenderables();
            
            void DrawIconWorldSpace(const IconDefinition& icon, const v2& shapedIconPos);
            
            IconRendererStateComponent* m_pIconRendererStateComponent;
            
            BatchedWorldIconRenderableCache* m_pBatchedWorldIconRenderableCache;
            
            m44 m_modelToWorldTransform;
        };
    }
}