ScreenIconRenderer.h

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

#pragma once

#include "Types.h"
#include "IScreenIconRenderer.h"
#include "VectorMath.h"
#include "Graphics.h"
#include "LayerIds.h"
#include "Rendering.h"
#include "Icons.h"
#include "BatchedIconRenderable.h"
#include "IconRendererStateComponent.h"
#include <vector>

namespace Eegeo
{
    namespace Icons
    {
        class ScreenIconRenderer : public IScreenIconRenderer, private Eegeo::NonCopyable
        {
        public:
            static ScreenIconRenderer* Create(IconMaterialSetFactory& iconMaterialSetFactory,
                                              IconMaterialSetCache& iconMaterialSetCache,
                                              IBatchedScreenIconRenderableFactory& batchedScreenIconRenderableFactory,
                                              BatchedScreenIconRenderable::VertexBufferType& screenIconVertexBuffer,
                                              bool snapToPixel);
            
            typedef TBatchedIconRenderableCache<BatchedScreenIconRenderable, IBatchedScreenIconRenderableFactory> BatchedScreenIconRenderableCache;
            
            ScreenIconRenderer(IconRendererStateComponent* pTextRendererStateComponent,
                               BatchedScreenIconRenderableCache* pBatchedScreenIconRenderableCache,
                               bool snapToPixel);
            ~ScreenIconRenderer();
            
            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 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();
            
            IconRendererStateComponent* m_pIconRendererStateComponent;
            
            BatchedScreenIconRenderableCache* m_pBatchedScreenIconRenderableCache;
            
            bool m_snapToPixel;
        };
    }
}