InteriorsFloorCell.h

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

#pragma once

#include "Types.h"
#include "Rendering.h"
#include "Interiors.h"
#include "InteriorsMaterials.h"
#include "MortonKey.h"
#include "VectorMath.h"
#include "InteriorRenderableSet.h"
#include "Labels.h"
#include "InteriorsFloorCellFeature.h"

#include <vector>
#include <string>
#include <map>

namespace Eegeo
{
    namespace Resources
    {
        namespace Interiors
        {
            class InteriorsFloorCell : private Eegeo::NonCopyable
            {
            public:
                static const std::string DefaultTag;
                static const std::string DefaultDetailTag;
                
                typedef std::map<std::string, InteriorRenderableSet*> TagToRenderableSetType;

                InteriorsFloorCell(const std::string& interiorName,
                                   const Streaming::MortonKey& cellKey,
                                   TagToRenderableSetType* pTagToRenderableSet,
                                   const std::vector<Rendering::Renderables::InteriorHighlightRenderable*>& interiorHighlightRenderables,
                                   const std::vector<Entities::InteriorsEntityModel*>& entityModels,
                                   const std::vector<Entities::InteriorsEntityGeometryView*>& entityGeometryViews,
                                   const Labels::LabelCellModel* pLabelCellModel,
                                   Labels::TransformedLabelCellModel* pTransformedLabelCellModel,
                                   const int floorNumber,
                                   InteriorsFloorCellFeatureContainer* pInteriorsFloorCellFeatureContainer,
                                   Resources::Interiors::Materials::IInteriorRenderablesRepository& interiorRenderablesRepository,
                                   const InteriorsFloorCellEntityPolygonContainer* interiorsFloorCellEntityPolygonContainer);

                ~InteriorsFloorCell();
                
                const Streaming::MortonKey& GetCellKey() const { return m_cellKey; }
                
                const std::string& GetInteriorId() const { return m_interiorName; }
                
                const dv3& GetCellOrigin() const { return m_cellCentreEcef; }

                bool ContainsRenderableSetForTag(const std::string& tag) const;
                
                InteriorRenderableSet& GetRenderableSetForTag(const std::string& tag) const;
                
                bool TryActivateTag(const std::string& tag) const;

                bool TryDeactivateTag(const std::string& tag) const;

                bool TryGetTagIsActive(const std::string& tag, bool &isActive) const;
                
                std::vector<Rendering::Renderables::InteriorFloorRenderable*> GetActiveFloorFeatureRenderables() const;

                std::vector<InteriorsStencilMirrorClearRenderable*> GetActiveStencilMirrorClearRenderables() const;

                std::vector<Rendering::Renderables::InstancedInteriorFloorRenderable*> GetActiveInstancedRenderables() const;

                std::vector<Rendering::Renderables::InstancedInteriorFloorRenderable*> GetInstancedRenderables() const;

                std::vector<Rendering::Renderables::InteriorHighlightRenderable*> GetHighlightRenderables() const;

                const std::vector<Entities::InteriorsEntityModel*>& GetEntityModels() const { return m_entityModels; }
                
                std::vector<Entities::InteriorsEntityGeometryView*> GetGeometryViews() const { return m_entityGeometryViews; }
                
                int GetFloorNumber() const { return m_floorNumber; }

                const InteriorsFloorCellFeatureContainer& GetInteriorsFloorCellFeatureContainer() const { return *m_pInteriorsFloorCellFeatureContainer; }

                const Labels::LabelCellModel& GetLabelCellModel() const { return *m_pLabelCellModel; }
                
                Labels::TransformedLabelCellModel& GetTransformedLabelCellModel() const { return *m_pTransformedLabelCellModel; }

                const InteriorsFloorCellEntityPolygonContainer& GetEntityPolygonContainer() const { return *m_pEntityPolygonContainer; }
                
                void UpdateFloorRenderables(const v4& defaultColor, const v4& detailColor, float saturation, const m44& modelTransform, const m44& normalTransform) const;
                
                void UpdateEntityRenderables(const v4& color, float saturation, const m44& modelTransform, const m44& normalTransform) const;
                
                void UpdateHighlightRenderables(const v4& floorColor, const m44& modelTransform, const m44& normalTransform) const;

            private:
                
                std::string m_interiorName;
                const Streaming::MortonKey m_cellKey;
                const dv3 m_cellCentreEcef;
                const std::vector<Entities::InteriorsEntityModel*> m_entityModels;
                const std::vector<Entities::InteriorsEntityGeometryView*> m_entityGeometryViews;
                TagToRenderableSetType* m_pTagToRenderableSet;
                std::vector<Rendering::Renderables::InteriorHighlightRenderable*> m_interiorHighlightRenderables;
                const Labels::LabelCellModel* m_pLabelCellModel;
                Labels::TransformedLabelCellModel* m_pTransformedLabelCellModel;
                const int m_floorNumber;
                InteriorsFloorCellFeatureContainer* m_pInteriorsFloorCellFeatureContainer;
                Resources::Interiors::Materials::IInteriorRenderablesRepository& m_interiorRenderablesRepository;
                const InteriorsFloorCellEntityPolygonContainer* m_pEntityPolygonContainer;
            };
        }
    }
}