[tmp] Logs.

drape/drape_diagnostics.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-//#define DRAW_TILE_NET
+#define DRAW_TILE_NET
 //#define DEBUG_OVERLAYS_OUTPUT
 
 //#define CHECK_VBO_BOUNDS
@@ -9,7 +9,7 @@
 //#define LINES_GENERATION_CALC_FILTERED_POINTS
 //#define GPS_TRACK_SHOW_RAW_POINTS
 //#define DEBUG_MESSAGE_QUEUE
-//#define RENDER_DEBUG_INFO_LABELS
+#define RENDER_DEBUG_INFO_LABELS
 
 //#define DRAPE_MEASURER_BENCHMARK
 //#define SCENARIO_ENABLE

drape_frontend/backend_renderer.cpp

@@ -1,10 +1,11 @@
-#include "drape_frontend/gui/drape_gui.hpp"
-
 #include "drape_frontend/backend_renderer.hpp"
+
 #include "drape_frontend/batchers_pool.hpp"
 #include "drape_frontend/circles_pack_shape.hpp"
 #include "drape_frontend/drape_api_builder.hpp"
+#ifdef DRAPE_MEASURER_BENCHMARK
 #include "drape_frontend/drape_measurer.hpp"
+#endif
 #include "drape_frontend/map_shape.hpp"
 #include "drape_frontend/message_subclasses.hpp"
 #include "drape_frontend/metaline_manager.hpp"
@@ -17,8 +18,6 @@
 #include "drape/support_manager.hpp"
 #include "drape/texture_manager.hpp"
 
-#include "indexer/scales.hpp"
-
 #include "platform/platform.hpp"
 
 #include "base/logging.hpp"
@@ -26,10 +25,10 @@
 #include <algorithm>
 #include <utility>
 
-using namespace std::placeholders;
-
 namespace df
 {
+using namespace std::placeholders;
+
 BackendRenderer::BackendRenderer(Params && params)
   : BaseRenderer(ThreadsCommutator::ResourceUploadThread, params)
   , m_model(params.m_model)
@@ -120,7 +119,8 @@ void BackendRenderer::RecacheChoosePositionMark()
 
 void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
 {
-  switch (message->GetType())
+  auto const type = message->GetType();
+  switch (type)
   {
   case Message::Type::UpdateReadManager:
     {
@@ -210,6 +210,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
     {
       TOverlaysRenderData overlays;
       overlays.swap(m_overlays);
+      LOG(LDEBUG, ("!VNG!", type, overlays.size()));
       m_commutator->PostMessage(ThreadsCommutator::RenderThread,
                                 make_unique_dp<FlushOverlaysMessage>(std::move(overlays)),
                                 MessagePriority::Normal);
@@ -682,7 +683,7 @@ void BackendRenderer::Routine::Do()
     m_renderer.IterateRenderLoop();
   m_renderer.ReleaseResources();
 }
-  
+
 void BackendRenderer::RenderFrame()
 {
   CHECK(m_context != nullptr, ());

drape_frontend/base_renderer.cpp

@@ -1,7 +1,6 @@
 #include "drape_frontend/base_renderer.hpp"
-#include "drape_frontend/message_subclasses.hpp"
 
-#include <utility>
+#include "base/logging.hpp"
 
 #if defined(OMIM_METAL_AVAILABLE)
 namespace dp
@@ -25,7 +24,6 @@ BaseRenderer::BaseRenderer(ThreadsCommutator::ThreadName name, Params const & pa
   , m_texMng(params.m_texMng)
   , m_threadName(name)
   , m_isEnabled(true)
-  , m_renderingEnablingCompletionHandler(nullptr)
   , m_wasNotified(false)
   , m_wasContextReset(false)
   , m_onGraphicsContextInitialized(params.m_onGraphicsContextInitialized)
@@ -36,29 +34,31 @@ BaseRenderer::BaseRenderer(ThreadsCommutator::ThreadName name, Params const & pa
 void BaseRenderer::StartThread()
 {
   m_selfThread.Create(CreateRoutine());
+
+  LOG(LDEBUG, ("!VNG!", m_isEnabled));
 }
 
 void BaseRenderer::StopThread()
 {
+  LOG(LDEBUG, ("!VNG!", m_isEnabled));
+
   // stop rendering and close queue
   m_selfThread.GetRoutine()->Cancel();
   CloseQueue();
 
   // wake up render thread if necessary
   if (!m_isEnabled)
-  {
     WakeUp();
-  }
 
   // wait for render thread completion
   m_selfThread.Join();
 }
-  
+
 void BaseRenderer::IterateRenderLoop()
 {
   RENDER_FRAME_MEDIATOR(IterateRenderLoopImpl());
 }
-  
+
 void BaseRenderer::IterateRenderLoopImpl()
 {
   RenderFrame();
@@ -89,19 +89,21 @@ void BaseRenderer::SetRenderingEnabled(bool const isEnabled)
   if (isEnabled == m_isEnabled)
     return;
 
+  LOG(LDEBUG, ("!VNG!", isEnabled));
+
   // here we have to wait for completion of internal SetRenderingEnabled
   std::mutex completionMutex;
   std::condition_variable completionCondition;
   bool notified = false;
   auto handler = [&]()
   {
-    std::lock_guard<std::mutex> lock(completionMutex);
+    std::lock_guard lock(completionMutex);
     notified = true;
     completionCondition.notify_one();
   };
 
   {
-    std::lock_guard<std::mutex> lock(m_completionHandlerMutex);
+    std::lock_guard lock(m_completionHandlerMutex);
     m_renderingEnablingCompletionHandler = std::move(handler);
   }
 
@@ -132,86 +134,89 @@ void BaseRenderer::CreateContext()
 {
   OnContextCreate();
 
-  m_contextCounter++;
-  uint8_t constexpr kContextCount = 2;
-  if (m_contextCounter == kContextCount && m_onGraphicsContextInitialized)
+  // Backend, frontend contexts.
+  if (++m_contextCounter == 2 && m_onGraphicsContextInitialized)
     m_onGraphicsContextInitialized();
 }
 
 void BaseRenderer::CheckRenderingEnabled()
 {
-  if (!m_isEnabled)
+  if (m_isEnabled)
+    return;
+
+  LOG(LDEBUG, ("!VNG! Enter", m_wasContextReset));
+
+  dp::GraphicsContext * context = nullptr;
+
+  if (m_wasContextReset)
   {
-    dp::GraphicsContext * context = nullptr;
+    using namespace std::placeholders;
+    EnableMessageFiltering(std::bind(&BaseRenderer::FilterContextDependentMessage, this, _1));
+    OnContextDestroy();
+    ASSERT_GREATER(m_contextCounter, 0, ());
+    --m_contextCounter;
+  }
+  else
+  {
+    bool const isDrawContext = m_threadName == ThreadsCommutator::RenderThread;
+    context = isDrawContext ? m_contextFactory->GetDrawContext() :
+                              m_contextFactory->GetResourcesUploadContext();
+    context->SetRenderingEnabled(false);
+  }
+
+  OnRenderingDisabled();
+
+  // notify initiator-thread about rendering disabling
+  Notify();
+
+  // wait for signal
+  std::unique_lock<std::mutex> lock(m_renderingEnablingMutex);
+  m_renderingEnablingCondition.wait(lock, [this] { return m_wasNotified; });
+
+  m_wasNotified = false;
+
+  bool needCreateContext = false;
+  if (!m_selfThread.GetRoutine()->IsCancelled())
+  {
+    LOG(LDEBUG, ("!VNG! Not cancelled", m_wasContextReset));
+
+    // here rendering is enabled again
+    m_isEnabled = true;
 
     if (m_wasContextReset)
     {
-      using namespace std::placeholders;
-      EnableMessageFiltering(std::bind(&BaseRenderer::FilterContextDependentMessage, this, _1));
-      OnContextDestroy();
-      CHECK(m_contextCounter > 0, ());
-      m_contextCounter--;
+      m_wasContextReset = false;
+      needCreateContext = true;
     }
     else
     {
-      bool const isDrawContext = m_threadName == ThreadsCommutator::RenderThread;
-      context = isDrawContext ? m_contextFactory->GetDrawContext() :
-                                m_contextFactory->GetResourcesUploadContext();
-      context->SetRenderingEnabled(false);
+      context->SetRenderingEnabled(true);
     }
-
-    OnRenderingDisabled();
-
-    // notify initiator-thread about rendering disabling
-    Notify();
-
-    // wait for signal
-    std::unique_lock<std::mutex> lock(m_renderingEnablingMutex);
-    m_renderingEnablingCondition.wait(lock, [this] { return m_wasNotified; });
-
-    m_wasNotified = false;
-
-    bool needCreateContext = false;
-    if (!m_selfThread.GetRoutine()->IsCancelled())
-    {
-      // here rendering is enabled again
-      m_isEnabled = true;
-
-      if (m_wasContextReset)
-      {
-        m_wasContextReset = false;
-        needCreateContext = true;
-      }
-      else
-      {
-        context->SetRenderingEnabled(true);
-      }
-    }
-
-    if (needCreateContext)
-      DisableMessageFiltering();
-
-    // notify initiator-thread about rendering enabling
-    // m_renderingEnablingCompletionHandler will be setup before awakening of this thread
-    Notify();
-
-    OnRenderingEnabled();
-
-    if (needCreateContext)
-      CreateContext();
   }
+
+  if (needCreateContext)
+    DisableMessageFiltering();
+
+  // notify initiator-thread about rendering enabling
+  // m_renderingEnablingCompletionHandler will be setup before awakening of this thread
+  Notify();
+
+  OnRenderingEnabled();
+
+  if (needCreateContext)
+    CreateContext();
 }
 
 void BaseRenderer::Notify()
 {
-  std::function<void()> handler;
+  TCompletionHandler handler;
   {
-    std::lock_guard<std::mutex> lock(m_completionHandlerMutex);
+    std::lock_guard lock(m_completionHandlerMutex);
     handler = std::move(m_renderingEnablingCompletionHandler);
-    m_renderingEnablingCompletionHandler = nullptr;
+    m_renderingEnablingCompletionHandler = {};
   }
 
-  if (handler != nullptr)
+  if (handler)
     handler();
 }
 

drape_frontend/base_renderer.hpp

@@ -2,7 +2,6 @@
 
 #include "drape_frontend/message_acceptor.hpp"
 #include "drape_frontend/threads_commutator.hpp"
-#include "drape_frontend/tile_utils.hpp"
 
 #include "drape/graphics_context_factory.hpp"
 #include "drape/texture_manager.hpp"
@@ -44,7 +43,7 @@ public:
   BaseRenderer(ThreadsCommutator::ThreadName name, Params const & params);
 
   bool CanReceiveMessages();
-  
+
   void IterateRenderLoop();
 
   void SetRenderingEnabled(ref_ptr<dp::GraphicsContextFactory> contextFactory);
@@ -65,9 +64,9 @@ protected:
   void CreateContext();
 
   void CheckRenderingEnabled();
-  
+
   virtual std::unique_ptr<threads::IRoutine> CreateRoutine() = 0;
-  
+
   virtual void RenderFrame() = 0;
 
   virtual void OnContextCreate() = 0;
@@ -78,7 +77,7 @@ protected:
 
 private:
   using TCompletionHandler = std::function<void()>;
-  
+
   void IterateRenderLoopImpl();
 
   threads::Thread m_selfThread;

drape_frontend/frontend_renderer.cpp

@@ -263,7 +263,8 @@ void FrontendRenderer::UpdateCanBeDeletedStatus()
 
 void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 {
-  switch (message->GetType())
+  auto const type = message->GetType();
+  switch (type)
   {
   case Message::Type::FlushTile:
     {
@@ -283,6 +284,9 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
     {
       ref_ptr<FlushOverlaysMessage> msg = message;
       TOverlaysRenderData renderData = msg->AcceptRenderData();
+      if (!renderData.empty())
+        LOG(LDEBUG, ("!VNG!", type, renderData.size()));
+
       for (auto & overlayRenderData : renderData)
       {
         if (overlayRenderData.m_tileKey.m_zoomLevel == GetCurrentZoom() &&
@@ -519,8 +523,12 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
       if (subrouteData->m_recacheId < 0)
         subrouteData->m_recacheId = m_lastRecacheRouteId;
 
+      LOG(LDEBUG, ("!VNG!", type, subrouteData->m_recacheId));
       if (!CheckRouteRecaching(make_ref(subrouteData)))
+      {
+        LOG(LDEBUG, ("!VNG! Failed recaching check"));
         break;
+      }
 
       m_routeRenderer->ClearObsoleteData(m_lastRecacheRouteId);
 
@@ -531,11 +539,14 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
       m_routeRenderer->PrepareRouteArrows(m_userEventStream.GetCurrentScreen(),
                                           std::bind(&FrontendRenderer::OnPrepareRouteArrows, this, _1, _2));
 
-      if (m_pendingFollowRoute != nullptr)
+      if (m_pendingFollowRoute)
       {
+        LOG(LDEBUG, ("!VNG! Resume pending FollowRoute"));
+
         FollowRoute(m_pendingFollowRoute->m_preferredZoomLevel,
                     m_pendingFollowRoute->m_preferredZoomLevelIn3d,
                     m_pendingFollowRoute->m_enableAutoZoom, m_pendingFollowRoute->m_isArrowGlued);
+
         m_pendingFollowRoute.reset();
       }
       break;
@@ -609,6 +620,8 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
       // receive FollowRoute message before FlushSubroute message, so we need to postpone its processing.
       if (m_routeRenderer->GetSubroutes().empty())
       {
+        LOG(LDEBUG, ("!VNG! Make pending FollowRoute"));
+
         m_pendingFollowRoute = std::make_unique<FollowRouteData>(
             msg->GetPreferredZoomLevel(), msg->GetPreferredZoomLevelIn3d(), msg->EnableAutoZoom(),
             msg->IsArrowGlued());
@@ -1067,6 +1080,8 @@ void FrontendRenderer::UpdateContextDependentResources()
 
   for (auto const & subroute : m_routeRenderer->GetSubroutes())
   {
+    LOG(LDEBUG, ("!VNG!", subroute.m_subrouteId, m_lastRecacheRouteId, GetCurrentZoom()));
+
     auto msg = make_unique_dp<AddSubrouteMessage>(subroute.m_subrouteId,
                                                   subroute.m_subroute,
                                                   m_lastRecacheRouteId);
@@ -1098,6 +1113,9 @@ void FrontendRenderer::UpdateContextDependentResources()
 void FrontendRenderer::FollowRoute(int preferredZoomLevel, int preferredZoomLevelIn3d,
                                    bool enableAutoZoom, bool isArrowGlued)
 {
+  LOG(LDEBUG, ("!VNG!", preferredZoomLevel, preferredZoomLevelIn3d, enableAutoZoom, isArrowGlued,
+               m_enablePerspectiveInNavigation));
+
   m_myPositionController->ActivateRouting(
       !m_enablePerspectiveInNavigation ? preferredZoomLevel : preferredZoomLevelIn3d,
       enableAutoZoom, isArrowGlued);

drape_frontend/message_queue.cpp

@@ -1,6 +1,7 @@
 #include "drape_frontend/message_queue.hpp"
 
 #include "base/assert.hpp"
+#include "base/logging.hpp"
 #include "base/stl_helpers.hpp"
 
 namespace df
@@ -43,46 +44,39 @@ void MessageQueue::PushMessage(drape_ptr<Message> && message, MessagePriority pr
 {
   std::lock_guard<std::mutex> lock(m_mutex);
 
-  if (m_filter != nullptr && m_filter(make_ref(message)))
+  if (m_filter && m_filter(make_ref(message)))
+  {
+    LOG(LDEBUG, ("!VNG! Filtered:", message->GetType()));
     return;
+  }
 
   switch (priority)
   {
   case MessagePriority::Normal:
-    {
-      m_messages.emplace_back(std::move(message), priority);
-      break;
-    }
+    m_messages.emplace_back(std::move(message), priority);
+    break;
   case MessagePriority::High:
     {
       auto iter = m_messages.begin();
-      while (iter != m_messages.end() && iter->second > MessagePriority::High) { iter++; }
+      while (iter != m_messages.end() && iter->second > MessagePriority::High)
+        ++iter;
       m_messages.emplace(iter, std::move(message), priority);
       break;
     }
   case MessagePriority::UberHighSingleton:
     {
-      bool found = false;
-      auto iter = m_messages.begin();
-      while (iter != m_messages.end() && iter->second == MessagePriority::UberHighSingleton)
+      auto const it = base::FindIf(m_messages, [](TMessageNode const & p)
       {
-        if (iter->first->GetType() == message->GetType())
-        {
-          found = true;
-          break;
-        }
-        iter++;
-      }
+        return p.second == MessagePriority::UberHighSingleton;
+      });
 
-      if (!found)
+      if (it == m_messages.end())
         m_messages.emplace_front(std::move(message), priority);
       break;
     }
   case MessagePriority::Low:
-    {
-      m_lowPriorityMessages.emplace_back(std::move(message));
-      break;
-    }
+    m_lowPriorityMessages.emplace_back(std::move(message));
+    break;
   default:
     ASSERT(false, ("Unknown message priority type"));
   }
@@ -92,23 +86,10 @@ void MessageQueue::PushMessage(drape_ptr<Message> && message, MessagePriority pr
 
 void MessageQueue::FilterMessagesImpl()
 {
-  CHECK(m_filter != nullptr, ());
+  ASSERT(m_filter, ());
 
-  for (auto it = m_messages.begin(); it != m_messages.end(); )
-  {
-    if (m_filter(make_ref(it->first)))
-      it = m_messages.erase(it);
-    else
-      ++it;
-  }
-
-  for (auto it = m_lowPriorityMessages.begin(); it != m_lowPriorityMessages.end(); )
-  {
-    if (m_filter(make_ref(*it)))
-      it = m_lowPriorityMessages.erase(it);
-    else
-      ++it;
-  }
+  base::EraseIf(m_messages, [this](TMessageNode const & p) { return m_filter(make_ref(p.first)); });
+  base::EraseIf(m_lowPriorityMessages, [this](drape_ptr<Message> const & p) { return m_filter(make_ref(p)); });
 }
 
 void MessageQueue::EnableMessageFiltering(FilterMessageFn && filter)
@@ -121,16 +102,16 @@ void MessageQueue::EnableMessageFiltering(FilterMessageFn && filter)
 void MessageQueue::DisableMessageFiltering()
 {
   std::lock_guard<std::mutex> lock(m_mutex);
-  m_filter = nullptr;
+  m_filter = {};
 }
 
 void MessageQueue::InstantFilter(FilterMessageFn && filter)
 {
   std::lock_guard<std::mutex> lock(m_mutex);
-  CHECK(m_filter == nullptr, ());
+  CHECK(!m_filter, ());
   m_filter = std::move(filter);
   FilterMessagesImpl();
-  m_filter = nullptr;
+  m_filter = {};
 }
 
 #ifdef DEBUG_MESSAGE_QUEUE

drape_frontend/read_manager.cpp

@@ -63,6 +63,8 @@ void ReadManager::Start()
   if (m_pool != nullptr)
     return;
 
+  LOG(LDEBUG, ("!VNG!"));
+
   ASSERT_EQUAL(m_counter, 0, ());
 
   m_pool = make_unique_dp<base::thread_pool::routine::ThreadPool>(kReadingThreadsCount,
@@ -73,7 +75,10 @@ void ReadManager::Stop()
 {
   InvalidateAll();
   if (m_pool != nullptr)
+  {
+    LOG(LDEBUG, ("!VNG!"));
     m_pool->Stop();
+  }
   m_pool.reset();
 }
 
@@ -117,7 +122,11 @@ void ReadManager::OnTaskFinished(threads::IRoutine * task)
                                 make_unique_dp<FinishTileReadMessage>(std::move(tiles),
                                                                       true /* forceUpdateUserMarks */),
                                 MessagePriority::Normal);
+
+      LOG(LDEBUG, ("!VNG! Finished tile", m_counter, key));
     }
+    else
+      LOG(LDEBUG, ("!VNG! Cancelled tile", m_counter, key));
   }
 
   t->Reset();
@@ -133,7 +142,10 @@ void ReadManager::UpdateCoverage(ScreenBase const & screen, bool have3dBuildings
   m_modeChanged |= (m_have3dBuildings != have3dBuildings);
   m_have3dBuildings = have3dBuildings;
 
-  if (m_modeChanged || forceUpdate || MustDropAllTiles(screen))
+  bool const init = m_modeChanged || forceUpdate || MustDropAllTiles(screen);
+  LOG(LDEBUG, ("!VNG!", init));
+
+  if (init)
   {
     m_modeChanged = false;
 
@@ -231,6 +243,8 @@ void ReadManager::PushTaskBackForTileKey(TileKey const & tileKey,
                                          ref_ptr<MetalineManager> metalineMng)
 {
   ASSERT(m_pool != nullptr, ());
+  LOG(LDEBUG, ("!VNG!", tileKey));
+
   auto context = make_unique_dp<EngineContext>(TileKey(tileKey, m_generationCounter,
                                                        m_userMarksGenerationCounter),
                                                m_commutator, texMng, metalineMng,
@@ -311,6 +325,8 @@ void ReadManager::IncreaseCounter(size_t value)
 
   ASSERT_GREATER_OR_EQUAL(m_counter, 0, ());
   m_counter += value;
+
+  LOG(LDEBUG, ("!VNG!", m_counter));
 }
 
 void ReadManager::Allow3dBuildings(bool allow3dBuildings)

drape_frontend/route_builder.cpp

@@ -18,6 +18,8 @@ void RouteBuilder::Build(ref_ptr<dp::GraphicsContext> context, dp::DrapeID subro
                          SubrouteConstPtr subroute, ref_ptr<dp::TextureManager> textures,
                          int recacheId)
 {
+  LOG(LDEBUG, ("!VNG!", subrouteId, recacheId));
+
   RouteCacheData cacheData;
   cacheData.m_polyline = subroute->m_polyline;
   cacheData.m_baseDepthIndex = subroute->m_baseDepthIndex;

drape_frontend/threads_commutator.cpp

@@ -3,24 +3,24 @@
 #include "drape_frontend/base_renderer.hpp"
 
 #include "base/assert.hpp"
-
-#include <utility>
+#include "base/logging.hpp"
 
 namespace df
 {
 
 void ThreadsCommutator::RegisterThread(ThreadName name, BaseRenderer * acceptor)
 {
-  VERIFY(m_acceptors.insert(std::make_pair(name, acceptor)).second, ());
+  VERIFY(m_acceptors.emplace(name, acceptor).second, ());
 }
 
 void ThreadsCommutator::PostMessage(ThreadName name, drape_ptr<Message> && message, MessagePriority priority)
 {
-  TAcceptorsMap::iterator it = m_acceptors.find(name);
+  auto it = m_acceptors.find(name);
   ASSERT(it != m_acceptors.end(), ());
-  if (it != m_acceptors.end() && it->second->CanReceiveMessages())
+  if (it->second->CanReceiveMessages())
     it->second->PostMessage(std::move(message), priority);
+  else
+    LOG(LDEBUG, ("!VNG! Can't receive messages:", name));
 }
 
 } // namespace df
-

drape_frontend/user_event_stream.cpp

@@ -131,6 +131,12 @@ void TouchEvent::Swap()
   SetSecondMaskedPointer(swapIndex(GetSecondMaskedPointer()));
 }
 
+SetAutoPerspectiveEvent::SetAutoPerspectiveEvent(bool isAutoPerspective)
+  : m_isAutoPerspective(isAutoPerspective)
+{
+  LOG(LDEBUG, ("!VNG!", isAutoPerspective));
+}
+
 UserEventStream::UserEventStream()
   : m_state(STATE_EMPTY)
   , m_animationSystem(AnimationSystem::Instance())

drape_frontend/user_event_stream.hpp

@@ -12,7 +12,6 @@
 #include "base/timer.hpp"
 
 #include <array>
-#include <bitset>
 #include <functional>
 #include <list>
 #include <memory>
@@ -314,9 +313,7 @@ private:
 class SetAutoPerspectiveEvent : public UserEvent
 {
 public:
-  explicit SetAutoPerspectiveEvent(bool isAutoPerspective)
-    : m_isAutoPerspective(isAutoPerspective)
-  {}
+  explicit SetAutoPerspectiveEvent(bool isAutoPerspective);
 
   EventType GetType() const override { return UserEvent::EventType::AutoPerspective; }