RoadNamesRenderableFilter.h

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

#pragma once

#include "Types.h"
#include "IRenderableFilter.h"
#include "Rendering.h"
#include "Roads.h"
#include "RoadNamesFadeController.h"
#include "VectorMath.h"
#include "EnvironmentFlatteningService.h"
#include "RenderContext.h"
#include "ISceneElementSource.h"
#include "TextRenderable.h"
#include "SceneElement.h"
#include "RenderQueue.h"
#include "RenderCamera.h"

#include <vector>

namespace Eegeo
{
    namespace Resources
    {
        namespace Roads
        {
            const float FadeOffsetHeight = 5.0f;

            class RoadNamesRenderableFilter : protected Eegeo::NonCopyable, public Rendering::IRenderableFilter
            {
            public:
                RoadNamesRenderableFilter(
                                          const Rendering::Scene::ISceneElementSource<Rendering::Renderables::TextRenderable>& sceneElementsSource,
                                          const Rendering::EnvironmentFlatteningService& environmentFlatteningService,
                                          const Resources::Roads::RoadNamesFadeController& roadNamesFadeController
                                          )
                : m_sceneElementsSource(sceneElementsSource)
                , m_environmentFlatteningService(environmentFlatteningService)
                , m_roadNamesFadeController(roadNamesFadeController)
                , m_enabled(true)
                {
                }
                
                void EnqueueRenderables(const Rendering::RenderContext& renderContext, Rendering::RenderQueue& renderQueue)
                {
                    if(!m_enabled)
                        return;

                    const float fadeParam = m_roadNamesFadeController.GetFadeParam();
                    
                    if(fadeParam > 0.0f)
                    {
                        const float environmentFlatteningScale = m_environmentFlatteningService.GetCurrentScale();
                        const float fadeOffsetMagnitude = FadeOffsetHeight * (1.0f - fadeParam);
                        
                        
                        const Camera::RenderCamera& renderCamera = renderContext.GetRenderCamera();
                        
                        const dv3& ecefCameraPosition = renderCamera.GetEcefLocation();
                        const m44& viewProjection = renderCamera.GetViewProjectionMatrix();
                        
                        typedef Rendering::Scene::SceneElement<Rendering::Renderables::TextRenderable> TSceneElement;
                        typedef std::vector<TSceneElement*> TSceneElementPtrVec;
                        TSceneElementPtrVec sceneElements;
                        m_sceneElementsSource.GetSceneElements(sceneElements);
                        
                        for (TSceneElementPtrVec::const_iterator it = sceneElements.begin(); it != sceneElements.end(); ++it)
                        {
                            const TSceneElement* pSceneElement = (*it);
                            
                            if(pSceneElement->IsInSceneGraph())
                            {
                                Rendering::Renderables::TextRenderable& renderable = pSceneElement->GetResource();
                            
                                Eegeo::v3 up = renderable.GetEcefPosition().ToSingle().Norm();

                            
                                const v3 flattening = up * (environmentFlatteningScale - 1.f);
                                renderable.SetScale(flattening);
                                
                                const v3 fadeOffset = up*fadeOffsetMagnitude;
                                
                                const m44& mvp = CalcMVP(renderable.GetEcefPosition(), ecefCameraPosition, viewProjection, fadeOffset);
                                
                                renderable.SetModelViewProjection(mvp);
                                renderable.SetAlpha(fadeParam);
                                
                                renderQueue.EnqueueRenderable(&renderable);
                            }
                        }
                    }
                }
                
                void SetEnabled(bool enabled) { m_enabled = enabled;}
                
            private:
                Eegeo::m44 CalcMVP(const dv3& ecefPosition, const dv3& ecefCameraPosition, const m44& viewProjection, const v3& fadeOffset) const
                {
                    v3 cameraLocalPos = (ecefPosition - ecefCameraPosition).ToSingle();
                    cameraLocalPos += fadeOffset;
                    Eegeo::m44 model, mvp;
                    model.Identity();
                    model.SetRow(3, Eegeo::v4(cameraLocalPos, 1));
                    Eegeo::m44::Mul(mvp, viewProjection, model);
                    return mvp;
                }
                
                const Rendering::Scene::ISceneElementSource<Rendering::Renderables::TextRenderable>& m_sceneElementsSource;
                const Rendering::EnvironmentFlatteningService& m_environmentFlatteningService;
                const Resources::Roads::RoadNamesFadeController& m_roadNamesFadeController;
                bool m_enabled;
            };
        }
    }
}