PinController.h

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

#pragma once

#include "Types.h"
#include "IPinObserver.h"
#include "PinRepository.h"
#include "TerrainHeightProvider.h"
#include "IPinViewFactory.h"
#include "PinViewRenderer.h"
#include "Pin.h"
#include "PinView.h"
#include "Pins.h"
#include <map>
#include <algorithm>

namespace Eegeo
{
    namespace Pins
    {
        class PinController : protected Eegeo::NonCopyable, public IPinObserver
        {
        public:
            PinController(PinRepository& pinRepository, Resources::Terrain::Heights::TerrainHeightProvider& terrainHeightProvider, IPinViewFactory& viewFactory, PinViewRenderer& viewRenderer)
            : m_pinRepository(pinRepository)
            , m_terrainHeightProvider(terrainHeightProvider)
            , m_viewFactory(viewFactory)
            , m_viewRenderer(viewRenderer)
            {
                m_pinRepository.AddPinObserver(*this);
            }
            
            ~PinController()
            {
                m_pinRepository.RemovePinObserver(*this);
                
                for(TViewsByModel::iterator it = m_viewsByModel.begin(); it != m_viewsByModel.end(); ++it)
                {
                    PinView* pView = it->second;
                    m_viewRenderer.RemoveView(*pView);
                    Eegeo_DELETE pView;
                }
                m_viewsByModel.clear();
            }
            
            void Update(float deltaTime, const Camera::RenderCamera& renderCamera)
            {
                UpdateTerrainHeights();
                UpdateViews();
                m_viewRenderer.Update(renderCamera);
            }
            
            virtual void OnPinAdded(Pin& pin)
            {
                Eegeo_ASSERT(!HasViewForModel(pin), "Attempt to add duplicate model to PinController.");
                
                PinView* pView = m_viewFactory.CreateViewForPin(pin);
                
                m_pinsNeedingHeightLookup.push_back(&pin);
                m_viewsByModel[&pin] = pView;
                m_viewRenderer.AddView(*pView);
            }
            
            virtual void OnPinRemoved(Pin& pin)
            {
                Eegeo_ASSERT(HasViewForModel(pin), "Attempt to remove unknown model from PinController.");
                PinView* pView = GetViewForModel(pin);
                
                m_pinsNeedingHeightLookup.erase(std::remove(m_pinsNeedingHeightLookup.begin(), m_pinsNeedingHeightLookup.end(), &pin), m_pinsNeedingHeightLookup.end());
                m_viewsByModel.erase(&pin);
                m_viewRenderer.RemoveView(*pView);
                
                Eegeo_DELETE(pView);
            }
            
            void GetScreenBoundsForPin(const Pin& pin, Geometry::Bounds2D& outScreenBounds) const
            {
                const PinView* pView = GetViewForModel(pin);
                Eegeo_ASSERT(pView != NULL, "Can't find screen bounds for a pin model that doesn't have a corresponding view.");
                
                outScreenBounds = pView->GetScreenSpaceBounds();
            }

            bool TryGetPinsIntersectingScreenPoint(const v2& screenPoint, std::vector<Pin*>& outIntersectingPins) const
            {
                outIntersectingPins.clear();
                
                std::vector<PinView*> intersectingViews;
                if(m_viewRenderer.TryGetViewsIntersectingScreenPoint(screenPoint, intersectingViews))
                {
                    for(std::vector<PinView*>::const_iterator it = intersectingViews.begin(); it != intersectingViews.end(); ++it)
                    {
                        PinView* pView = *it;
                        outIntersectingPins.push_back(&(pView->GetPin()));
                    }
                }
                
                return (outIntersectingPins.size() > 0);
            }
            
            
            float GetScaleForPin(const Pin& pin) const
            {
                const PinView* pView = GetViewForModel(pin);
                Eegeo_ASSERT(pView != NULL, "Can't get scale for a pin model that doesn't have a corresponding view.");
                return pView->GetScale();
            }
            
            void SetScaleForPin(const Pin& pin, float pinScale)
            {
                PinView* pView = GetViewForModel(pin);
                Eegeo_ASSERT(pView != NULL, "Can't set scale for a pin model that doesn't have a corresponding view.");
                pView->SetScale(pinScale);
            }
            
        protected:
            virtual void UpdateViews()
            {
                for(TViewsByModel::iterator it = m_viewsByModel.begin(); it != m_viewsByModel.end(); ++it)
                {
                    const Pin* pPin = it->first;
                    PinView* pView = it->second;
                    
                    const dv3& origin = pPin->GetEcefPosition();
                    pView->SetEcefOrigin(origin);
                    pView->SetTransform(pPin->GetTransform());
                    pView->SetTransformOrigin(pPin->GetTransformOrigin());
                    pView->SetColor(pPin->GetColor());
                }
            }
            
        private:
            PinRepository& m_pinRepository;
            Resources::Terrain::Heights::TerrainHeightProvider& m_terrainHeightProvider;
            IPinViewFactory& m_viewFactory;
            PinViewRenderer& m_viewRenderer;
            
            typedef std::map<Pin*, PinView*> TViewsByModel;
            
            std::vector<Pin*> m_pinsNeedingHeightLookup;
            
            TViewsByModel m_viewsByModel;
            
            PinView* GetViewForModel(const Pin& pin) const
            {
                TViewsByModel::const_iterator foundPin = m_viewsByModel.find(const_cast<Pin*>(&pin));
                
                if(foundPin != m_viewsByModel.end())
                {
                    return foundPin->second;
                }
                
                return NULL;
            }
            
            bool HasViewForModel(const Pin& pin) const
            {
                return (GetViewForModel(pin) != NULL);
            }
            
            void UpdateTerrainHeights()
            {
                const int maxPinsToUpdatePerFrame = 30;
                const int numberOfPinsNeedingLookup = static_cast<int>(m_pinsNeedingHeightLookup.size());
                int pinsToUpdateThisFrame = std::min(numberOfPinsNeedingLookup, maxPinsToUpdatePerFrame);
                
                while (pinsToUpdateThisFrame--)
                {
                    Pin* pPin = m_pinsNeedingHeightLookup.back();
                    
                    float terrainHeight;
                    int queryTerminationLevel;
                    
                    if(m_terrainHeightProvider.TryGetHeight(pPin->GetEcefGeoidLocation(),
                                                            0,
                                                            pPin->TerrainHeightLevel(),
                                                            pPin->TerrainHeight(),
                                                            queryTerminationLevel,
                                                            terrainHeight))
                    {
                        pPin->SetTerrainHeight(terrainHeight, queryTerminationLevel);
                    }
                    
                    m_pinsNeedingHeightLookup.pop_back();
                }
                
                int numOfPinsInRepo = m_pinRepository.GetNumOfPins();
                if (m_pinsNeedingHeightLookup.empty() && numOfPinsInRepo > 0)
                {
                    RepopulatePinLookupVector();
                }
            }
            
            void RepopulatePinLookupVector()
            {
                for (int pinIndex = 0; pinIndex < m_pinRepository.GetNumOfPins(); ++pinIndex)
                {
                    Pin *pPin = m_pinRepository.GetPinAtIndex(pinIndex);
                    m_pinsNeedingHeightLookup.push_back(pPin);
                }
            }
        };
    }
}