MapCameraModel.h

#pragma once

#include "MapCamera.h"
#include "Types.h"
#include "ScreenProperties.h"
#include "CameraState.h"
#include "MapCameraEvents.h"
#include "Space.h"
#include "MapCameraPosition.h"
#include "MapCameraAnimationOptions.h"
#include "MapCameraUpdate.h"
#include "MapCameraGestureState.h"

namespace Eegeo
{
    namespace Camera
    {
        namespace MapCamera
        {
            class MapCameraModel : private Eegeo::NonCopyable
            {
            public:
                MapCameraModel(
                    const Rendering::ScreenProperties& screenProperties,
                    IMapCameraModelChangedEvent& mapCameraModelChangedEvent,
                    IMapCameraModelScreenPropertiesChangedEvent& screenProperyChangedEvent,
                    IMapCameraTransitionCancelledEvent& mapCameraTransitionCancelledEvent
                );

                ~MapCameraModel();

                void SetScreenProperties(const Rendering::ScreenProperties& screenProperties);

                const Rendering::ScreenProperties& GetScreenProperties() const;

                void SetUsingCustomStreamingCamera(bool usingCustomStreamingCamera);

                bool IsUsingCustomStreamingCamera() const { return m_isUsingCustomStreamingCamera; }

                void SetUsingCustomRenderCamera(bool usingCustomRenderCamera);

                bool IsUsingCustomRenderCamera() const { return m_isUsingCustomRenderCamera; }

                IMapCameraModelChangedEvent& GetMapCameraChangedEvent() const;
                IMapCameraModelScreenPropertiesChangedEvent& GetScreenPropertiesChangedEvent() const;

                // MapCameraCoordinator sets state on this model after IndoorOutdoorModalCameraController has done 'update'
                void SetUpdateState(
                    const MapCameraPosition& mapCameraPosition,
                    const MapCameraGestureState& mapCameraGestureState
                );

                void SetMoveState(const MapCameraPosition& mapCameraPosition);

                void SetAnimationState(
                    int animationId,
                    const MapCameraPosition& animationTarget,
                    double animationDuration,
                    bool isInterruptByGestureAllowed,
                    bool isInterruptByApiAllowed,
                    bool isAnimationSnapToTarget
                );

                void ClearAnimationState();
                
                void SetIndoorMapEntryInitialDistance(double indoorMapEntryInitialDistance);
                double GetIndoorMapEntryInitialDistance() const { return m_indoorMapEntryInitialDistance; }

                const MapCameraPosition& GetMapCameraPosition() const { return m_mapCameraPosition;}
                const MapCameraGestureState& GetMapCameraGesture() const { return m_mapCameraGestureState; }

                int GetAnimationId() const { return m_animationId; }
                double GetAnimationDuration() const { return m_animationDuration; }
                const MapCameraPosition& GetAnimationTarget() const { return m_animationTarget; }
                bool IsInterruptAnimationByGestureAllowed() const { return m_isInterruptAnimationByGestureAllowed;  }
                bool IsInterruptByApiAllowed() const { return m_isInterruptByApiAllowed; }
                bool IsAnimationSnapToTarget() const { return m_isAnimationSnapToTarget; }
                bool IsAnimating() const { return m_animationId != InvalidMapCameraAnimationId; }

                void SetIndoorRestriction(bool indoorRestrictionApplied);
                bool IsIndoorRestrictionEnabled() const { return m_isIndoorRestrictionApplied; }

                void SetVerticallyLocked(bool isVerticallyLocked);
                bool IsVerticallyLocked() const { return m_isVerticallyLocked; }

            private:

                void SetUpdateStateInternal(
                    const MapCameraPosition& mapCameraPosition,
                    const MapCameraGestureState& mapCameraGestureState,
                    bool forceMove
                );

                void RaiseChangedEvent(const MapCameraOperation::Type operation);

                void RaiseGestureEvents(bool prevGestureActive,
                                        bool newGestureActive,
                                        bool changed,
                                        MapCameraOperation::Type start,
                                        MapCameraOperation::Type end,
                                        MapCameraOperation::Type change);



                // canonical state for map camera
                Rendering::ScreenProperties m_screenProperties;
                MapCameraGestureState m_mapCameraGestureState;
                MapCameraPosition m_mapCameraPosition;
                MapCameraPosition m_animationTarget;
                int m_animationId;
                double m_animationDuration;
                bool m_isInterruptAnimationByGestureAllowed;
                bool m_isInterruptByApiAllowed;
                bool m_isAnimationSnapToTarget;
                double m_indoorMapEntryInitialDistance;
                bool m_isMoving;
                bool m_isUsingCustomStreamingCamera;
                bool m_isUsingCustomRenderCamera;
                bool m_isIndoorRestrictionApplied;
                bool m_isVerticallyLocked;

                IMapCameraModelChangedEvent& m_mapCameraModelChangedEvent;
                IMapCameraModelScreenPropertiesChangedEvent& m_screenProperyChangedEvent;
                IMapCameraTransitionCancelledEvent& m_mapCameraTransitionCancelledEvent;
            };
        }
    }
}