gpesquero/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[drape] my position controller

Browse source 
- gps, compass info messages
- my position rendering fixes
- remove useless code
This commit is contained in:
ExMix 2015-05-21 13:02:42 +03:00 • committed by r.kuznetsov
parent fa5be671cd
commit 5fde96bf58
21 changed files with 1038 additions and 1036 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
drape/shaders/position_accuracy_shader.vsh
View file

@ -11,8 +11,9 @@ varying vec2 v_colorTexCoords;
void main(void)
{
vec4 position = vec4(u_position.xy + normalize(a_normal) * u_accuracy, u_position.z, 1);
gl_Position = position * modelView * projection;
vec4 position = vec4(u_position, 1.0) * modelView;
vec4 normal = vec4(normalize(a_normal) * u_accuracy, 0.0, 0.0);
gl_Position = (position + normal) * projection;
v_colorTexCoords = a_colorTexCoords;
}

62
drape_frontend/drape_engine.cpp
View file

@ -8,6 +8,8 @@
#include "drape/texture_manager.hpp"
#include "platform/settings.hpp"
#include "platform/platform.hpp"
#include "std/bind.hpp"
@ -30,6 +32,8 @@ void ConnectDownloadFn(gui::CountryStatusHelper::EButtonType buttonType, MapData
});
}
string const LocationStateMode = "LastLocationStateMode";
}
DrapeEngine::DrapeEngine(Params const & params)
@ -57,10 +61,16 @@ DrapeEngine::DrapeEngine(Params const & params)
m_textureManager = make_unique_dp<dp::TextureManager>();
m_threadCommutator = make_unique_dp<ThreadsCommutator>();
int modeValue = 0;
if (!Settings::Get(LocationStateMode, modeValue))
modeValue = location::MODE_FOLLOW;
FrontendRenderer::Params frParams(make_ref(m_threadCommutator), params.m_factory,
make_ref(m_textureManager), m_viewport,
bind(&DrapeEngine::ModelViewChanged, this, _1),
params.m_model.GetIsCountryLoadedFn());
params.m_model.GetIsCountryLoadedFn(),
bind(&DrapeEngine::MyPositionModeChanged, this, _1),
static_cast<location::EMyPositionMode>(modeValue));
m_frontend = make_unique_dp<FrontendRenderer>(frParams);
@ -169,6 +179,16 @@ void DrapeEngine::ModelViewChangedGuiThread(ScreenBase const & screen)
p.second(screen);
}
void DrapeEngine::MyPositionModeChanged(location::EMyPositionMode mode)
{
GetPlatform().RunOnGuiThread([this, mode]()
{
Settings::Set(LocationStateMode, static_cast<int>(mode));
if (m_myPositionModeChanged != nullptr)
m_myPositionModeChanged(mode);
});
}
void DrapeEngine::SetCountryInfo(gui::CountryInfo const & info, bool isCurrentCountry, bool isCountryLoaded)
{
m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
@ -176,4 +196,44 @@ void DrapeEngine::SetCountryInfo(gui::CountryInfo const & info, bool isCurrentCo
MessagePriority::Normal);
}
void DrapeEngine::SetCompassInfo(location::CompassInfo const & info)
{
m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
make_unique_dp<CompassInfoMessage>(info),
MessagePriority::High);
}
void DrapeEngine::SetGpsInfo(location::GpsInfo const & info, bool isNavigable, const location::RouteMatchingInfo & routeInfo)
{
m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
make_unique_dp<GpsInfoMessage>(info, isNavigable, routeInfo),
MessagePriority::High);
}
void DrapeEngine::MyPositionNextMode()
{
m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
make_unique_dp<ChangeMyPositionModeMessage>(ChangeMyPositionModeMessage::TYPE_NEXT),
MessagePriority::High);
}
void DrapeEngine::CancelMyPosition()
{
m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
make_unique_dp<ChangeMyPositionModeMessage>(ChangeMyPositionModeMessage::TYPE_CANCEL),
MessagePriority::High);
}
void DrapeEngine::InvalidateMyPosition()
{
m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
make_unique_dp<ChangeMyPositionModeMessage>(ChangeMyPositionModeMessage::TYPE_INVALIDATE),
MessagePriority::High);
}
void DrapeEngine::SetMyPositionModeListener(location::TMyPositionModeChanged const & fn)
{
m_myPositionModeChanged = fn;
}
} // namespace df

12
drape_frontend/drape_engine.hpp
View file

@ -7,6 +7,8 @@
#include "drape/pointers.hpp"
#include "drape/texture_manager.hpp"
#include "platform/location.hpp"
#include "geometry/screenbase.hpp"
#include "base/strings_bundle.hpp"
@ -73,12 +75,20 @@ public:
void SetRenderingEnabled(bool const isEnabled);
void SetCountryInfo(gui::CountryInfo const & info, bool isCurrentCountry, bool isCountryLoaded);
void SetCompassInfo(location::CompassInfo const & info);
void SetGpsInfo(location::GpsInfo const & info, bool isNavigable, location::RouteMatchingInfo const & routeInfo);
void MyPositionNextMode();
void CancelMyPosition();
void InvalidateMyPosition();
void SetMyPositionModeListener(location::TMyPositionModeChanged const & fn);
private:
void AddUserEvent(UserEvent const & e);
void ModelViewChanged(ScreenBase const & screen);
void ModelViewChangedGuiThread(ScreenBase const & screen);
void MyPositionModeChanged(location::EMyPositionMode mode);
private:
drape_ptr<FrontendRenderer> m_frontend;
drape_ptr<BackendRenderer> m_backend;
@ -89,6 +99,8 @@ private:
using TListenerMap = map<int, TModelViewListenerFn>;
TListenerMap m_listeners;
location::TMyPositionModeChanged m_myPositionModeChanged;
};
} // namespace df

2
drape_frontend/drape_frontend.pro
View file

@ -50,6 +50,7 @@ SOURCES += \
visual_params.cpp \
my_position.cpp \
user_event_stream.cpp \
my_position_controller.cpp
HEADERS += \
animation/base_interpolator.hpp \
@ -98,3 +99,4 @@ HEADERS += \
visual_params.hpp \
my_position.hpp \
user_event_stream.hpp \
my_position_controller.hpp

54
drape_frontend/frontend_renderer.cpp
View file

@ -52,6 +52,9 @@ FrontendRenderer::FrontendRenderer(Params const & params)
m_fps = 0.0;
#endif
m_myPositionController.reset(new MyPositionController(params.m_initMyPositionMode));
m_myPositionController->SetModeListener(params.m_myPositionModeCallback);
StartThread();
}
@ -124,9 +127,6 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
break;
}
case Message::MyPositionShape:
m_myPositionMark = ref_ptr<MyPositionShapeMessage>(message)->AcceptShape();
break;
case Message::InvalidateRect:
{
@ -156,6 +156,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
m_userMarkRenderGroups.erase(iter, m_userMarkRenderGroups.end());
break;
}
case Message::ChangeUserMarkLayerVisibility:
{
ref_ptr<ChangeUserMarkLayerVisibilityMessage> m = message;
@ -166,6 +167,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
m_userMarkVisibility.erase(key);
break;
}
case Message::GuiLayerRecached:
{
ref_ptr<GuiLayerRecachedMessage> msg = message;
@ -177,11 +179,52 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
m_guiRenderer->Merge(make_ref(renderer));
break;
}
case Message::StopRendering:
{
ProcessStopRenderingMessage();
break;
}
case Message::MyPositionShape:
m_myPositionController->SetRenderShape(ref_ptr<MyPositionShapeMessage>(message)->AcceptShape());
break;
case Message::ChangeMyPostitionMode:
{
ref_ptr<ChangeMyPositionModeMessage> msg = message;
switch (msg->GetChangeType())
{
case ChangeMyPositionModeMessage::TYPE_NEXT:
m_myPositionController->NextMode();
break;
case ChangeMyPositionModeMessage::TYPE_INVALIDATE:
m_myPositionController->Invalidate();
break;
case ChangeMyPositionModeMessage::TYPE_CANCEL:
m_myPositionController->TurnOf();
break;
default:
ASSERT(false, ());
break;
}
break;
}
case Message::CompassInfo:
{
ref_ptr<CompassInfoMessage> msg = message;
m_myPositionController->OnCompassUpdate(msg->GetInfo());
break;
}
case Message::GpsInfo:
{
ref_ptr<GpsInfoMessage> msg = message;
m_myPositionController->OnLocationUpdate(msg->GetInfo(), msg->IsNavigable());
break;
}
default:
ASSERT(false, ());
}
@ -315,8 +358,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView)
if (prevLayer != layer && layer == dp::GLState::OverlayLayer)
{
GLFunctions::glClearDepth();
if (m_myPositionMark != nullptr)
m_myPositionMark->Render(modelView, make_ref(m_gpuProgramManager), m_generalUniforms);
m_myPositionController->Render(modelView, make_ref(m_gpuProgramManager), m_generalUniforms);
}
prevLayer = layer;
@ -538,7 +580,7 @@ void FrontendRenderer::ReleaseResources()
m_deferredRenderGroups.clear();
m_userMarkRenderGroups.clear();
m_guiRenderer.reset();
m_myPositionMark.reset();
m_myPositionController.reset();
m_gpuProgramManager.reset();
}

14
drape_frontend/frontend_renderer.hpp
View file

@ -14,7 +14,7 @@
#include "drape_frontend/tile_tree.hpp"
#include "drape_frontend/backend_renderer.hpp"
#include "drape_frontend/render_group.hpp"
#include "drape_frontend/my_position.hpp"
#include "drape_frontend/my_position_controller.hpp"
#include "drape_frontend/navigator.hpp"
#include "drape_frontend/user_event_stream.hpp"
@ -27,6 +27,8 @@
#include "drape/overlay_tree.hpp"
#include "drape/uniform_values_storage.hpp"
#include "platform/location.hpp"
#include "geometry/screenbase.hpp"
#include "std/function.hpp"
@ -50,16 +52,22 @@ public:
ref_ptr<dp::TextureManager> texMng,
Viewport viewport,
TModelViewChanged const & modelViewChangedFn,
TIsCountryLoaded const & isCountryLoaded)
TIsCountryLoaded const & isCountryLoaded,
location::TMyPositionModeChanged myPositionModeCallback,
location::EMyPositionMode initMode)
: BaseRenderer::Params(commutator, factory, texMng)
, m_viewport(viewport)
, m_modelViewChangedFn(modelViewChangedFn)
, m_isCountryLoadedFn(isCountryLoaded)
, m_myPositionModeCallback(myPositionModeCallback)
, m_initMyPositionMode(initMode)
{}
Viewport m_viewport;
TModelViewChanged m_modelViewChangedFn;
TIsCountryLoaded m_isCountryLoadedFn;
location::TMyPositionModeChanged m_myPositionModeCallback;
location::EMyPositionMode m_initMyPositionMode;
};
FrontendRenderer(Params const & params);
@ -140,7 +148,7 @@ private:
set<TileKey> m_userMarkVisibility;
drape_ptr<gui::LayerRenderer> m_guiRenderer;
drape_ptr<MyPosition> m_myPositionMark;
drape_ptr<MyPositionController> m_myPositionController;
dp::UniformValuesStorage m_generalUniforms;

5
drape_frontend/message.hpp
View file

@ -25,7 +25,10 @@ public:
GuiRecache,
MyPositionShape,
CountryInfoUpdate,
StopRendering
StopRendering,
ChangeMyPostitionMode,
CompassInfo,
GpsInfo
};
virtual ~Message() {}

58
drape_frontend/message_subclasses.hpp
View file

@ -17,6 +17,8 @@
#include "drape/pointers.hpp"
#include "drape/render_bucket.hpp"
#include "platform/location.hpp"
#include "std/shared_ptr.hpp"
#include "std/set.hpp"
#include "std/function.hpp"
@ -290,4 +292,60 @@ public:
Type GetType() const override { return Message::StopRendering; }
};
class ChangeMyPositionModeMessage : public Message
{
public:
enum EChangeType
{
TYPE_NEXT,
TYPE_CANCEL,
TYPE_INVALIDATE
};
ChangeMyPositionModeMessage(EChangeType changeType)
: m_changeType(changeType)
{
}
EChangeType GetChangeType() const { return m_changeType; }
Type GetType() const override { return Message::ChangeMyPostitionMode; }
private:
EChangeType m_changeType;
};
class CompassInfoMessage : public Message
{
public:
CompassInfoMessage(location::CompassInfo const & info)
: m_info(info)
{}
Type GetType() const override { return Message::CompassInfo; }
location::CompassInfo const & GetInfo() const { return m_info; }
private:
location::CompassInfo m_info;
};
class GpsInfoMessage : public Message
{
public:
GpsInfoMessage(location::GpsInfo const & info, bool isNavigable, location::RouteMatchingInfo const & routeInfo)
: m_info(info)
, m_isNavigable(isNavigable)
, m_routeInfo(routeInfo)
{}
Type GetType() const override { return Message::GpsInfo; }
location::GpsInfo const & GetInfo() const { return m_info; }
bool IsNavigable() const { return m_isNavigable; }
location::RouteMatchingInfo const & GetRouteInfo() const { return m_routeInfo; }
private:
location::GpsInfo m_info;
bool m_isNavigable;
location::RouteMatchingInfo m_routeInfo;
};
} // namespace df

38
drape_frontend/my_position.cpp
View file

@ -54,7 +54,6 @@ MyPosition::MyPosition(ref_ptr<dp::TextureManager> mng)
, m_azimut(0.0f)
, m_accuracy(0.0f)
, m_showAzimut(false)
, m_isVisible(false)
{
m_parts.resize(3);
CacheAccuracySector(mng);
@ -71,36 +70,35 @@ void MyPosition::SetAzimut(float azimut)
m_azimut = azimut;
}
void MyPosition::SetIsValidAzimut(bool isValid)
{
m_showAzimut = isValid;
}
void MyPosition::SetAccuracy(float accuracy)
{
m_accuracy = accuracy;
}
void MyPosition::SetIsVisible(bool isVisible)
{
m_isVisible = isVisible;
}
void MyPosition::Render(ScreenBase const & screen,
ref_ptr<dp::GpuProgramManager> mng,
dp::UniformValuesStorage const & commonUniforms)
{
if (!m_isVisible)
return;
dp::UniformValuesStorage uniforms = commonUniforms;
{
m2::PointD accuracyPoint(m_position.x + m_accuracy, m_position.y);
float pixelAccuracy = (screen.GtoP(accuracyPoint) - screen.GtoP(m_position)).Length();
dp::UniformValuesStorage accuracyUniforms = uniforms;
accuracyUniforms.SetFloatValue("u_position", m_position.x, m_position.y, dp::depth::POSITION_ACCURACY);
accuracyUniforms.SetFloatValue("u_accuracy", m_accuracy);
accuracyUniforms.SetFloatValue("u_accuracy", pixelAccuracy);
RenderPart(mng, accuracyUniforms, MY_POSITION_ACCURACY);
}
{
dp::UniformValuesStorage arrowUniforms = uniforms;
arrowUniforms.SetFloatValue("u_position", m_position.x, m_position.y, dp::depth::MY_POSITION_MARK);
arrowUniforms.SetFloatValue("u_azimut", m_azimut - screen.GetAngle());
arrowUniforms.SetFloatValue("u_azimut", -(m_azimut + screen.GetAngle()));
RenderPart(mng, arrowUniforms, (m_showAzimut == true) ? MY_POSITION_ARROW : MY_POSITION_POINT);
}
}
@ -108,7 +106,7 @@ void MyPosition::Render(ScreenBase const & screen,
void MyPosition::CacheAccuracySector(ref_ptr<dp::TextureManager> mng)
{
int const TriangleCount = 40;
int const VertexCount = TriangleCount + 2;
int const VertexCount = 3 * TriangleCount;
float const etalonSector = math::twicePi / static_cast<double>(TriangleCount);
dp::TextureManager::ColorRegion color;
@ -116,14 +114,18 @@ void MyPosition::CacheAccuracySector(ref_ptr<dp::TextureManager> mng)
glsl::vec2 colorCoord = glsl::ToVec2(color.GetTexRect().Center());
buffer_vector<Vertex, TriangleCount> buffer;
buffer.emplace_back(glsl::vec2(0.0f, 0.0f), colorCoord);
//buffer.emplace_back(glsl::vec2(0.0f, 0.0f), colorCoord);
glsl::vec2 startNormal(0.0f, 1.0f);
for (size_t i = 0; i < TriangleCount + 1; ++i)
{
glsl::vec2 rotatedNormal = glsl::rotate(startNormal, -(i * etalonSector));
buffer.emplace_back(rotatedNormal, colorCoord);
glsl::vec2 normal = glsl::rotate(startNormal, i * etalonSector);
glsl::vec2 nextNormal = glsl::rotate(startNormal, (i + 1) * etalonSector);
buffer.emplace_back(startNormal, colorCoord);
buffer.emplace_back(normal, colorCoord);
buffer.emplace_back(nextNormal, colorCoord);
}
dp::GLState state(gpu::ACCURACY_PROGRAM, dp::GLState::OverlayLayer);
@ -143,7 +145,7 @@ void MyPosition::CacheAccuracySector(ref_ptr<dp::TextureManager> mng)
dp::AttributeProvider provider(1 /*stream count*/, VertexCount);
provider.InitStream(0 /*stream index*/, GetBindingInfo(), make_ref(buffer.data()));
m_parts[MY_POSITION_ACCURACY].first = batcher.InsertTriangleFan(state, make_ref(&provider), nullptr);
m_parts[MY_POSITION_ACCURACY].first = batcher.InsertTriangleList(state, make_ref(&provider), nullptr);
ASSERT(m_parts[MY_POSITION_ACCURACY].first.IsValid(), ());
}
}
@ -198,9 +200,9 @@ void MyPosition::CachePointPosition(ref_ptr<dp::TextureManager> mng)
m_parts[MY_POSITION_POINT].second = m_nodes.size();
m_parts[MY_POSITION_ARROW].second = m_nodes.size();
m_parts[MY_POSITION_POINT].first = batcher.InsertTriangleFan(state, make_ref(&pointProvider), nullptr);
m_parts[MY_POSITION_POINT].first = batcher.InsertTriangleStrip(state, make_ref(&pointProvider), nullptr);
ASSERT(m_parts[MY_POSITION_POINT].first.IsValid(), ());
m_parts[MY_POSITION_ARROW].first = batcher.InsertTriangleFan(state, make_ref(&arrowProvider), nullptr);
m_parts[MY_POSITION_ARROW].first = batcher.InsertTriangleStrip(state, make_ref(&arrowProvider), nullptr);
ASSERT(m_parts[MY_POSITION_ARROW].first.IsValid(), ());
}
}

3
drape_frontend/my_position.hpp
View file

@ -19,8 +19,8 @@ public:
///@param pt = mercator point
void SetPosition(m2::PointF const & pt);
void SetAzimut(float azimut);
void SetIsValidAzimut(bool isValid);
void SetAccuracy(float accuracy);
void SetIsVisible(bool isVisible);
void Render(ScreenBase const & screen,
ref_ptr<dp::GpuProgramManager> mng,
@ -62,7 +62,6 @@ private:
float m_azimut;
float m_accuracy;
bool m_showAzimut;
bool m_isVisible;
using TPart = pair<dp::IndicesRange, size_t>;

302
drape_frontend/my_position_controller.cpp Normal file
View file

@ -0,0 +1,302 @@
#include "my_position_controller.hpp"
#include "indexer/mercator.hpp"
#include "3party/Alohalytics/src/alohalytics.h"
namespace df
{
namespace
{
static const double GPS_BEARING_LIFETIME_S = 5.0;
uint16_t IncludeModeBit(uint16_t mode, uint16_t bit)
{
return mode | bit;
}
//uint16_t ExcludeModeBit(uint16_t mode, uint16_t bit)
//{
// return mode & (~bit);
//}
location::EMyPositionMode ExcludeAllBits(uint16_t mode)
{
return (location::EMyPositionMode)(mode & 0xF);
}
uint16_t ChangeMode(uint16_t mode, location::EMyPositionMode newMode)
{
return (mode & 0xF0) | newMode;
}
bool TestModeBit(uint16_t mode, uint16_t bit)
{
return (mode & bit) != 0;
}
} // namespace
MyPositionController::MyPositionController(location::EMyPositionMode initMode)
: m_modeInfo(location::MODE_PENDING_POSITION)
, m_afterPendingMode(location::MODE_FOLLOW)
, m_errorRadius(0.0)
, m_position(m2::PointD::Zero())
, m_drawDirection(0.0)
, m_lastGPSBearing(false)
, m_isVisible(false)
{
if (initMode > location::MODE_UNKNOWN_POSITION)
m_afterPendingMode = initMode;
else
m_modeInfo = location::MODE_UNKNOWN_POSITION;
}
m2::PointD const & MyPositionController::Position() const
{
return m_position;
}
double MyPositionController::GetErrorRadius() const
{
return m_errorRadius;
}
bool MyPositionController::IsModeChangeViewport() const
{
return GetMode() >= location::MODE_FOLLOW;
}
bool MyPositionController::IsModeHasPosition() const
{
return GetMode() >= location::MODE_NOT_FOLLOW;
}
void MyPositionController::SetRenderShape(drape_ptr<MyPosition> && shape)
{
m_shape = move(shape);
}
void MyPositionController::SetFixedZoom()
{
SetModeInfo(IncludeModeBit(m_modeInfo, FixedZoomBit));
}
void MyPositionController::NextMode()
{
string const kAlohalyticsClickEvent = "$onClick";
location::EMyPositionMode currentMode = GetMode();
location::EMyPositionMode newMode = currentMode;
if (!IsInRouting())
{
switch (currentMode)
{
case location::MODE_UNKNOWN_POSITION:
alohalytics::LogEvent(kAlohalyticsClickEvent, "@UnknownPosition");
newMode = location::MODE_PENDING_POSITION;
break;
case location::MODE_PENDING_POSITION:
alohalytics::LogEvent(kAlohalyticsClickEvent, "@PendingPosition");
newMode = location::MODE_UNKNOWN_POSITION;
m_afterPendingMode = location::MODE_FOLLOW;
break;
case location::MODE_NOT_FOLLOW:
alohalytics::LogEvent(kAlohalyticsClickEvent, "@NotFollow");
newMode = location::MODE_FOLLOW;
break;
case location::MODE_FOLLOW:
alohalytics::LogEvent(kAlohalyticsClickEvent, "@Follow");
if (IsRotationActive())
newMode = location::MODE_ROTATE_AND_FOLLOW;
else
{
newMode = location::MODE_UNKNOWN_POSITION;
m_afterPendingMode = location::MODE_FOLLOW;
}
break;
case location::MODE_ROTATE_AND_FOLLOW:
alohalytics::LogEvent(kAlohalyticsClickEvent, "@RotateAndFollow");
newMode = location::MODE_UNKNOWN_POSITION;
m_afterPendingMode = location::MODE_FOLLOW;
break;
}
}
else
newMode = IsRotationActive() ? location::MODE_ROTATE_AND_FOLLOW : location::MODE_FOLLOW;
SetModeInfo(ChangeMode(m_modeInfo, newMode));
}
void MyPositionController::TurnOf()
{
StopLocationFollow();
SetModeInfo(location::MODE_UNKNOWN_POSITION);
SetIsVisible(false);
}
void MyPositionController::Invalidate()
{
location::EMyPositionMode currentMode = GetMode();
if (currentMode > location::MODE_PENDING_POSITION)
{
SetModeInfo(ChangeMode(m_modeInfo, location::MODE_UNKNOWN_POSITION));
SetModeInfo(ChangeMode(m_modeInfo, location::MODE_PENDING_POSITION));
m_afterPendingMode = currentMode;
SetIsVisible(true);
}
else if (currentMode == location::MODE_UNKNOWN_POSITION)
{
m_afterPendingMode = location::MODE_FOLLOW;
SetIsVisible(false);
}
}
void MyPositionController::OnLocationUpdate(location::GpsInfo const & info, bool isNavigable)
{
Assign(info, isNavigable);
SetIsVisible(true);
if (GetMode() == location::MODE_PENDING_POSITION)
{
SetModeInfo(ChangeMode(m_modeInfo, m_afterPendingMode));
m_afterPendingMode = location::MODE_FOLLOW;
}
else
AnimateFollow();
}
void MyPositionController::OnCompassUpdate(location::CompassInfo const & info)
{
if (Assign(info))
AnimateFollow();
}
void MyPositionController::SetModeListener(location::TMyPositionModeChanged const & fn)
{
m_modeChangeCallback = fn;
CallModeListener(m_modeInfo);
}
void MyPositionController::Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng,
dp::UniformValuesStorage const & commonUniforms)
{
if (m_shape != nullptr && IsVisible() && GetMode() > location::MODE_PENDING_POSITION)
{
m_shape->SetPosition(m_position);
m_shape->SetAzimut(m_drawDirection);
m_shape->SetIsValidAzimut(IsRotationActive());
m_shape->SetAccuracy(m_errorRadius);
m_shape->Render(screen, mng, commonUniforms);
}
}
void MyPositionController::AnimateStateTransition(location::EMyPositionMode oldMode, location::EMyPositionMode newMode)
{
}
void MyPositionController::AnimateFollow()
{
}
void MyPositionController::Assign(location::GpsInfo const & info, bool isNavigable)
{
m2::RectD rect = MercatorBounds::MetresToXY(info.m_longitude,
info.m_latitude,
info.m_horizontalAccuracy);
m_position = rect.Center();
m_errorRadius = rect.SizeX() / 2;
bool const hasBearing = info.HasBearing();
if ((isNavigable && hasBearing)
|| (!isNavigable && hasBearing && info.HasSpeed() && info.m_speed > 1.0))
{
SetDirection(my::DegToRad(info.m_bearing));
m_lastGPSBearing.Reset();
}
}
bool MyPositionController::Assign(location::CompassInfo const & info)
{
if ((IsInRouting() && GetMode() >= location::MODE_FOLLOW) ||
(m_lastGPSBearing.ElapsedSeconds() < GPS_BEARING_LIFETIME_S))
return false;
SetDirection(info.m_bearing);
return true;
}
void MyPositionController::SetDirection(double bearing)
{
m_drawDirection = bearing;
SetModeInfo(IncludeModeBit(m_modeInfo, KnownDirectionBit));
}
void MyPositionController::SetModeInfo(uint16_t modeInfo, bool force)
{
location::EMyPositionMode const newMode = ExcludeAllBits(modeInfo);
location::EMyPositionMode const oldMode = GetMode();
m_modeInfo = modeInfo;
if (newMode != oldMode || force)
{
AnimateStateTransition(oldMode, newMode);
CallModeListener(newMode);
}
}
location::EMyPositionMode MyPositionController::GetMode() const
{
return ExcludeAllBits(m_modeInfo);
}
void MyPositionController::CallModeListener(uint16_t mode)
{
if (m_modeChangeCallback != nullptr)
m_modeChangeCallback(ExcludeAllBits(mode));
}
bool MyPositionController::IsInRouting() const
{
return TestModeBit(m_modeInfo, RoutingSessionBit);
}
bool MyPositionController::IsRotationActive() const
{
return TestModeBit(m_modeInfo, KnownDirectionBit);
}
void MyPositionController::StopLocationFollow()
{
location::EMyPositionMode currentMode = GetMode();
if (currentMode > location::MODE_NOT_FOLLOW)
{
StopAllAnimations();
SetModeInfo(ChangeMode(m_modeInfo, location::MODE_NOT_FOLLOW));
}
else if (currentMode == location::MODE_PENDING_POSITION)
{
StopAllAnimations();
m_afterPendingMode = location::MODE_NOT_FOLLOW;
}
}
void MyPositionController::StopCompassFollow()
{
if (GetMode() != location::MODE_ROTATE_AND_FOLLOW)
return;
StopAllAnimations();
SetModeInfo(ChangeMode(m_modeInfo, location::MODE_FOLLOW));
}
void MyPositionController::StopAllAnimations()
{
// TODO
}
}

88
drape_frontend/my_position_controller.hpp Normal file
View file

@ -0,0 +1,88 @@
#pragma once
#include "drape_frontend/my_position.hpp"
#include "drape/gpu_program_manager.hpp"
#include "drape/uniform_values_storage.hpp"
#include "platform/location.hpp"
#include "geometry/screenbase.hpp"
#include "base/timer.hpp"
namespace df
{
class MyPositionController
{
public:
MyPositionController(location::EMyPositionMode initMode);
m2::PointD const & Position() const;
double GetErrorRadius() const;
bool IsModeChangeViewport() const;
bool IsModeHasPosition() const;
void SetRenderShape(drape_ptr<MyPosition> && shape);
void SetFixedZoom();
void NextMode();
void TurnOf();
void Invalidate();
void OnLocationUpdate(location::GpsInfo const & info, bool isNavigable);
void OnCompassUpdate(location::CompassInfo const & info);
void SetModeListener(location::TMyPositionModeChanged const & fn);
void Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng,
dp::UniformValuesStorage const & commonUniforms);
private:
void AnimateStateTransition(location::EMyPositionMode oldMode, location::EMyPositionMode newMode);
void AnimateFollow();
void Assign(location::GpsInfo const & info, bool isNavigable);
bool Assign(location::CompassInfo const & info);
void SetDirection(double bearing);
void SetModeInfo(uint16_t modeInfo, bool force = false);
location::EMyPositionMode GetMode() const;
void CallModeListener(uint16_t mode);
bool IsInRouting() const;
bool IsRotationActive() const;
void StopLocationFollow();
void StopCompassFollow();
void StopAllAnimations();
bool IsVisible() const { return m_isVisible; }
void SetIsVisible(bool isVisible) { m_isVisible = isVisible; }
private:
// Mode bits
// {
static uint16_t const FixedZoomBit = 0x20;
static uint16_t const RoutingSessionBit = 0x40;
static uint16_t const KnownDirectionBit = 0x80;
// }
uint16_t m_modeInfo; // combination of Mode enum and "Mode bits"
location::EMyPositionMode m_afterPendingMode;
location::TMyPositionModeChanged m_modeChangeCallback;
drape_ptr<MyPosition> m_shape;
double m_errorRadius; //< error radius in mercator
m2::PointD m_position; //< position in mercator
double m_drawDirection;
my::Timer m_lastGPSBearing;
bool m_isVisible;
};
}

62
map/framework.cpp
View file

@ -33,8 +33,6 @@
#include "storage/country_info_getter.hpp"
#include "anim/controller.hpp"
#include "platform/local_country_file_utils.hpp"
#include "platform/measurement_utils.hpp"
#include "platform/mwm_version.hpp"
@ -99,7 +97,10 @@ pair<MwmSet::MwmId, MwmSet::RegResult> Framework::RegisterMap(
return m_model.RegisterMap(localFile);
}
void Framework::OnLocationError(TLocationError /*error*/) {}
void Framework::OnLocationError(TLocationError /*error*/)
{
CallDrapeFunction(bind(&df::DrapeEngine::CancelMyPosition, _1));
}
void Framework::OnLocationUpdate(GpsInfo const & info)
{
@ -130,12 +131,7 @@ void Framework::OnLocationUpdate(GpsInfo const & info)
double distanceFromBegin = 0.0;
MatchLocationToRoute(rInfo, routeMatchingInfo, hasDistanceFromBegin, distanceFromBegin);
///@TODO UVR
//shared_ptr<State> const & state = GetLocationState();
//state->OnLocationUpdate(rInfo, m_routingSession.IsNavigable());
//if (state->IsModeChangeViewport())
// UpdateUserViewportChanged();
CallDrapeFunction(bind(&df::DrapeEngine::SetGpsInfo, _1, rInfo, m_routingSession.IsNavigable(), routeMatchingInfo));
}
void Framework::OnCompassUpdate(CompassInfo const & info)
@ -147,8 +143,24 @@ void Framework::OnCompassUpdate(CompassInfo const & info)
CompassInfo const & rInfo = info;
#endif
///@TODO UVR
//GetLocationState()->OnCompassUpdate(rInfo);
CallDrapeFunction(bind(&df::DrapeEngine::SetCompassInfo, _1, rInfo));
}
void Framework::SwitchMyPositionNextMode()
{
CallDrapeFunction(bind(&df::DrapeEngine::MyPositionNextMode, _1));
}
void Framework::InvalidateMyPosition()
{
ASSERT(m_drapeEngine != nullptr, ());
CallDrapeFunction(bind(&df::DrapeEngine::InvalidateMyPosition, _1));
}
void Framework::SetMyPositionModeListener(location::TMyPositionModeChanged const & fn)
{
ASSERT(m_drapeEngine != nullptr, ());
CallDrapeFunction(bind(&df::DrapeEngine::SetMyPositionModeListener, _1, fn));
}
void Framework::CallDrapeFunction(TDrapeFunction const & fn)
@ -159,21 +171,11 @@ void Framework::CallDrapeFunction(TDrapeFunction const & fn)
void Framework::StopLocationFollow()
{
///@TODO UVR
//GetLocationState()->StopLocationFollow();
}
InformationDisplay & Framework::GetInformationDisplay()
{
return m_informationDisplay;
CallDrapeFunction(bind(&df::DrapeEngine::CancelMyPosition, _1));
}
Framework::Framework()
: m_queryMaxScaleMode(false),
m_width(0),
m_height(0),
m_animController(new anim::Controller),
m_bmManager(*this),
: m_bmManager(*this),
m_balloonManager(*this),
m_fixedSearchResults(0),
m_locationChangedSlotID(-1)
@ -710,15 +712,7 @@ void Framework::RemoveViewportListener(int slotID)
void Framework::OnSize(int w, int h)
{
if (w < 2) w = 2;
if (h < 2) h = 2;
CallDrapeFunction(bind(&df::DrapeEngine::Resize, _1, w, h));
m_width = w;
m_height = h;
///@TODO UVR
//GetLocationState()->OnSize();
CallDrapeFunction(bind(&df::DrapeEngine::Resize, _1, max(w, 2), max(h, 2)));
}
namespace
@ -1399,7 +1393,9 @@ void Framework::SetupMeasurementSystem()
Settings::Get("Units", units);
m_routingSession.SetTurnNotificationsUnits(units);
m_informationDisplay.measurementSystemChanged();
//m_informationDisplay.measurementSystemChanged();
///@TODO UVR
//Invalidate();
}

29
map/framework.hpp
View file

@ -1,14 +1,10 @@
#pragma once
#include "map/active_maps_layout.hpp"
#include "map/animator.hpp"
#include "map/bookmark.hpp"
#include "map/bookmark_manager.hpp"
#include "map/country_tree.hpp"
#include "map/feature_vec_model.hpp"
#include "map/information_display.hpp"
#include "map/location_state.hpp"
#include "map/move_screen_task.hpp"
#include "map/mwm_url.hpp"
#include "map/pin_click_manager.hpp"
#include "map/routing_session.hpp"
@ -54,7 +50,6 @@ namespace storage
class CountryInfoGetter;
}
namespace anim { class Controller; }
namespace routing { namespace turns{ class Settings; } }
class StorageBridge;
@ -110,17 +105,11 @@ protected:
double m_startForegroundTime;
bool m_queryMaxScaleMode;
int m_width;
int m_height;
void StopLocationFollow();
storage::Storage m_storage;
shared_ptr<storage::ActiveMapsLayout> m_activeMaps;
storage::CountryTree m_globalCntTree;
InformationDisplay m_informationDisplay;
/// How many pixels around touch point are used to get bookmark or POI
static const int TOUCH_PIXEL_RADIUS = 20;
@ -132,16 +121,6 @@ protected:
/// This function is called by m_model when the map file is deregistered.
void OnMapDeregistered(platform::LocalCountryFile const & localFile);
//my::Timer m_timer;
inline double ElapsedSeconds() const
{
//return m_timer.ElapsedSeconds();
return 0.0;
}
///@TODO UVR
///void DrawAdditionalInfo(shared_ptr<PaintEvent> const & e);
BookmarkManager m_bmManager;
PinClickManager m_balloonManager;
@ -271,6 +250,9 @@ public:
void OnLocationError(location::TLocationError error);
void OnLocationUpdate(location::GpsInfo const & info);
void OnCompassUpdate(location::CompassInfo const & info);
void SwitchMyPositionNextMode();
void InvalidateMyPosition();
void SetMyPositionModeListener(location::TMyPositionModeChanged const & fn);
//@}
void CreateDrapeEngine(ref_ptr<dp::OGLContextFactory> contextFactory, float vs, int w, int h);
@ -280,8 +262,6 @@ public:
void SetMapStyle(MapStyle mapStyle);
MapStyle GetMapStyle() const;
InformationDisplay & GetInformationDisplay();
void PrepareToShutdown();
void SetupMeasurementSystem();
@ -424,9 +404,6 @@ public:
PinClickManager & GetBalloonManager() { return m_balloonManager; }
///@TODO UVR
//shared_ptr<location::State> const & GetLocationState() const;
/// [in] lat, lon - last known location
/// [out] lat, lon - predicted location
static void PredictLocation(double & lat, double & lon, double accuracy,

1144
map/location_state.cpp
View file

File diff suppressed because it is too large Load diff

167
map/location_state.hpp
View file

@ -16,8 +16,6 @@
class Framework;
class ScreenBase;
namespace anim { class Task;}
namespace location
{
class GpsInfo;
@ -30,165 +28,34 @@ namespace location
{
public:
struct Params
{
///@TODO UVR
//graphics::Color m_locationAreaColor;
Framework * m_framework;
Params();
};
// void RouteBuilded();
// void StartRouteFollow();
// void StopRoutingMode();
// Do not change the order and values
enum Mode
{
UnknownPosition = 0x0,
PendingPosition = 0x1,
NotFollow = 0x2,
Follow = 0x3,
RotateAndFollow = 0x4,
};
// /// @name User input notification block
// //@{
// void DragStarted();
// void DragEnded();
typedef function<void(Mode)> TStateModeListener;
typedef function<void (m2::PointD const &)> TPositionListener;
// void ScaleStarted();
// void CorrectScalePoint(m2::PointD & pt) const;
// void CorrectScalePoint(m2::PointD & pt1, m2::PointD & pt2) const;
// void ScaleEnded();
State(Params const & p);
// void Rotated();
// //@}
/// @return GPS center point in mercator
m2::PointD const & Position() const;
double GetErrorRadius() const;
double GetDirection() const { return m_drawDirection; }
bool IsDirectionKnown() const;
// void OnCompassTaped();
Mode GetMode() const;
bool IsModeChangeViewport() const;
bool IsModeHasPosition() const;
void SwitchToNextMode();
void RouteBuilded();
void StartRouteFollow(int scale);
void StopRoutingMode();
int AddStateModeListener(TStateModeListener const & l);
void RemoveStateModeListener(int slotID);
int AddPositionChangedListener(TPositionListener const & func);
void RemovePositionChangedListener(int slotID);
void InvalidatePosition();
void TurnOff();
void StopCompassFollowing();
void StopLocationFollow(bool callListeners = true);
void SetFixedZoom();
void SetRoutingNotFollow();
/// @name User input notification block
//@{
void DragStarted();
void DragEnded();
void ScaleStarted();
void CorrectScalePoint(m2::PointD & pt) const;
void CorrectScalePoint(m2::PointD & pt1, m2::PointD & pt2) const;
void ScaleEnded();
void Rotated();
//@}
void OnCompassTaped();
void OnSize();
/// @name GPS location updates routine.
//@{
void OnLocationUpdate(location::GpsInfo const & info, bool isNavigable, location::RouteMatchingInfo const & routeMatchingInfo);
void OnCompassUpdate(location::CompassInfo const & info);
//@}
RouteMatchingInfo const & GetRouteMatchingInfo() const { return m_routeMatchingInfo; }
void ResetRouteMatchingInfo() { m_routeMatchingInfo.Reset(); }
void ResetDirection();
/// @name Override from graphics::OverlayElement and gui::Element.
//@{
///@TODO UVR
//virtual m2::RectD GetBoundRect() const { return m2::RectD(); }
bool hitTest(m2::PointD const & /*pt*/) const { return false; }
void cache();
void purge();
void update();
//@}
// void OnSize();
private:
void AnimateStateTransition(Mode oldMode, Mode newMode);
void AnimateFollow();
void RotateOnNorth();
void CallPositionChangedListeners(m2::PointD const & pt);
void CallStateModeListeners();
bool IsRotationActive() const;
bool IsInRouting() const;
bool IsRoutingFollowingDisabled() const;
m2::PointD const GetModeDefaultPixelBinding(Mode mode) const;
m2::PointD const GetRaFModeDefaultPxBind() const;
void SetModeInfo(uint16_t modeInfo, bool callListeners = true);
void StopAllAnimations();
ScreenBase const & GetModelView() const;
void Assign(location::GpsInfo const & info, bool isNavigable);
bool Assign(location::CompassInfo const & info);
void SetDirection(double bearing);
const m2::PointD GetPositionForDraw() const;
//m2::PointD const GetModeDefaultPixelBinding(Mode mode) const;
//m2::PointD const GetRaFModeDefaultPxBind() const;
private:
enum ExternalMode
{
RoutingNotFollowBit = 0x10,
FixedZoomBit = 0x20,
RoutingSessionBit = 0x40,
KnownDirectionBit = 0x80
};
static uint16_t const s_cacheRadius = 500.0f;
uint16_t m_modeInfo; // combination of Mode enum and "Mode bits"
uint16_t m_dragModeInfo = 0;
uint16_t m_scaleModeInfo = 0;
Framework * m_framework;
double m_errorRadius; //< error radius in mercator
m2::PointD m_position; //< position in mercator
double m_drawDirection;
my::Timer m_lastGPSBearing;
Mode m_afterPendingMode;
RouteMatchingInfo m_routeMatchingInfo;
typedef map<int, TStateModeListener> TModeListeners;
typedef map<int, TPositionListener> TPositionListeners;
TModeListeners m_modeListeners;
TPositionListeners m_positionListeners;
int m_currentSlotID;
/// @name Compass Rendering Parameters
//@{
//@}
/// @name Rotation mode animation
//@{
shared_ptr<anim::Task> m_animTask;
bool FollowCompass();
void CreateAnimTask();
void CreateAnimTask(m2::PointD const & srcPx, m2::PointD const & dstPx);
void EndAnimation();
//@}
};
}

6
map/map.pro
View file

@ -24,9 +24,6 @@ HEADERS += \
framework.hpp \
ge0_parser.hpp \
geourl_process.hpp \
information_display.hpp \
location_state.hpp \
move_screen_task.hpp \
mwm_url.hpp \
pin_click_manager.hpp \
route_track.hpp \
@ -52,9 +49,6 @@ SOURCES += \
framework.cpp \
ge0_parser.cpp \
geourl_process.cpp \
information_display.cpp \
location_state.cpp \
move_screen_task.cpp \
mwm_url.cpp \
pin_click_manager.cpp \
route_track.cpp \

2
map/route_track.cpp
View file

@ -1,7 +1,5 @@
#include "map/route_track.hpp"
#include "map/location_state.hpp"
#include "indexer/scales.hpp"
#include "std/array.hpp"

2
map/route_track.hpp
View file

@ -2,6 +2,8 @@
#include "map/track.hpp"
#include "platform/location.hpp"
#include "routing/turns.hpp"
#include "drape/drape_global.hpp"

16
platform/location.hpp
View file

@ -1,5 +1,7 @@
#pragma once
#include "geometry/point2d.hpp"
#include "base/base.hpp"
#include "geometry/latlon.hpp"
@ -8,6 +10,7 @@
#include "routing/turns_sound_settings.hpp"
#include "std/cmath.hpp"
#include "std/function.hpp"
#include "std/string.hpp"
#include "std/vector.hpp"
@ -189,4 +192,17 @@ namespace location
size_t GetIndexInRoute() const { return m_indexInRoute; }
m2::PointD GetPosition() const { return m_matchedPosition; }
};
// Do not change the order and values
enum EMyPositionMode
{
MODE_UNKNOWN_POSITION = 0x0,
MODE_PENDING_POSITION = 0x1,
MODE_NOT_FOLLOW = 0x2,
MODE_FOLLOW = 0x3,
MODE_ROTATE_AND_FOLLOW = 0x4,
};
using TMyPositionModeChanged = function<void (location::EMyPositionMode)>;
} // namespace location

3
routing/route.cpp
View file

@ -12,9 +12,6 @@
#include "base/logging.hpp"
#include "std/numeric.hpp"
#include "std/utility.hpp"
#include "std/algorithm.hpp"
namespace routing
{