InteriorsModel.h

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

#pragma once

#include "Interiors.h"
#include "InteriorsMaterials.h"
#include "IdTypes.h"
#include "Space.h"
#include "VectorMath.h"
#include "Rendering.h"
#include "EcefTangentBasis.h"
#include <string>
#include <vector>
#include "Bounds.h"
#include "InteriorsEntityMetadata.h"
#include "MortonKey.h"
#include "ICallback.h"
#include "CallbackCollection.h"
#include "InteriorRenderableCreationData.h"
#include "Types.h"

namespace Eegeo
{
    namespace Resources
    {
        namespace Interiors
        {
            typedef std::vector<InteriorsFloorModel*> TFloorModelVector;
            
            class InteriorsModel : Eegeo::NonCopyable
            {
            public:
                InteriorsModel(const std::string& interiorIdString,
                               const std::string& displayName,
                               const std::string& associatedLandmarkMaterialName,
                               const std::string& sourceVendor,
                               const Space::EcefTangentBasis& tangentSpace,
                               const Geometry::Bounds3D& localEcefBounds,
                               const Geometry::Bounds3D& tangentSpaceBounds,
                               const Entities::TCategoryToEntitiesMetadata& entitiesMetadata,
                               const std::vector<InteriorsFloorModel*>& floorModels,
                               const std::vector<InteriorsFloorCells*>& interiorsFloorCells,
                               const int defaultFloorIndex,
                               const std::vector<Eegeo::Streaming::MortonKey>& intersectingCellKeys,
                               Materials::IInteriorRenderablesRepository& interiorRenderablesRepository);
                
                ~InteriorsModel();
                
                const InteriorId GetId() const;
                
                const std::string& GetName() const;
                const std::string& GetDisplayName() const;
                const std::string& GetAssociatedLandmarkMaterialName() const;
                const std::string& GetSourceVendor() const;

                int GetMiddleFloorIndex() const;
                
                const TFloorModelVector& GetFloors() const;
                const InteriorsFloorModel& GetFloorAtIndex(int floorIndex) const;
                int GetFloorCount() const { return static_cast<int>(m_floorModels.size()); }
                
                const InteriorsFloorModel* GetBottomFloor() const;
                const int GetDefaultFloorIndex() const;
                int FindFloorIndexWithFloorNumber(int floorNumber) const;
                
                const Eegeo::Space::EcefTangentBasis& GetTangentBasis() const { return m_tangentBasis; }
                
                const Geometry::Bounds3D& GetLocalEcefBounds() const { return m_localEcefBounds; }
                const Geometry::Bounds3D& GetTangentSpaceBounds() const { return m_tangentSpaceBounds; }
                const std::vector<Eegeo::Streaming::MortonKey>& GetIntersectingCellKeys() const { return m_intersectingCellKeys; }
                
                float GetBaseAltitude() const;
                float GetFloorAltitude(int floorIndex) const;
                
                const Entities::InteriorsEntityMetadata* GetMetadataForEntity(const std::string& entityId) const;
                const Entities::InteriorsEntityMetadata* GetMetadataForEntityFromCategory(const std::string& category, const std::string& entityId) const;
                
                // Cell/View methods
                const InteriorsFloorCells* GetFloorCells(int floorNumber) const;
                InteriorsFloorCells* GetFloorCellsMutable(int floorNumber) const;
                std::vector<const InteriorsFloorCell*> GetAllFloorCells() const;
                std::vector<Eegeo::Streaming::MortonKey> GetCurrentlyLoadedFloorCellKeys() const;
                
                void IncrementCellInMemoryReferenceCount();
                void DecrementCellInMemoryReferenceCount();
                void IncrementCellVisibleReferenceCount();
                void DecrementCellVisibleReferenceCount();
                void SetShouldPreventEviction(bool preventEviction);
                
                const bool AnyCellsInMemory() const { return m_cellsInMemoryRefCount > 0; }
                const bool AnyCellsVisible() const { return m_cellsVisibilityRefCount > 0; }
                const bool ShouldPreventEviction() const { return m_preventEviction; }
                
                void RegisterCellsInMemoryChangedCallback(Helpers::ICallback1<const InteriorsModel&>& callback);
                void UnregisterCellsInMemoryChangedCallback(Helpers::ICallback1<const InteriorsModel&>& callback);
                void RegisterCellsVisibilityChangedCallback(Helpers::ICallback1<const InteriorsModel&>& callback);
                void UnregisterCellsVisibilityChangedCallback(Helpers::ICallback1<const InteriorsModel&>& callback);
                void RegisterPreventEvictionChangedCallback(Helpers::ICallback1<const InteriorsModel&>& callback);
                void UnregisterPreventEvictionChangedCallback(Helpers::ICallback1<const InteriorsModel&>& callback);
 
                
            private:
                void RefreshFloorTransforms();
                
                std::string m_interiorIdString;
                std::string m_displayName;
                std::string m_associatedLandmarkMaterialName;
                std::string m_sourceVendor;

                Eegeo::Space::EcefTangentBasis m_tangentBasis;

                Entities::TCategoryToEntitiesMetadata* m_pEntitiesMetadata;

                Geometry::Bounds3D m_localEcefBounds;
                Geometry::Bounds3D m_tangentSpaceBounds;

                TFloorModelVector m_floorModels;
                int m_defaultFloorIndex;
                std::vector<Eegeo::Streaming::MortonKey> m_intersectingCellKeys;

                // Cell/View methods
                std::vector<InteriorsFloorCells*> m_floorCellsPerFloor;
                int m_cellsInMemoryRefCount;
                int m_cellsVisibilityRefCount;
                bool m_preventEviction;

                Materials::IInteriorRenderablesRepository& m_interiorRenderablesRepository;

                Helpers::CallbackCollection1<const InteriorsModel&> m_cellsInMemoryChangedCallbacks;
                Helpers::CallbackCollection1<const InteriorsModel&> m_cellsVisibilityChangedCallbacks;
                Helpers::CallbackCollection1<const InteriorsModel&> m_preventEvictionChangedCallbacks;
            };
        }
    }
}