green-anger / globeviewer Goto Github PK

From experience it looks like moving is more frequent operation considering #30. So should revert #14.

It must:

• download tiles
• cache tiles
• check cache prior to downloading

In the context of this issue the class should download and cache tiles for map zoom levels 0, 1 and 2 (21 tiles in total).

Good articles to consider from OpenStreetMap wiki:

• Zoom levels
• Slippy map tilenames

It should have been an abbreviation for GlobeViewer, so it must be gv not gw.

Usually tile servers have several sub-domains. It's probably more efficient to download from different mirrors than from a single server.

This includes the following:

• Tile
• TileServer
• TileTexture
• ViewData
• consts in Defines.h

GlobeViewer already supports two tile servers (OpenStreetMap and 2Gis). There should be API method in GlobeViewer.h and a trigger using it in GLFW example to change the server on the fly.

Limits must be defined for points [0,+90], [0,-90], [90,0] and [-90,0] with projection center in [0,0].
Limits must be considered in zooming.

It's good to know current FPS

TileManager::dirs_ consider only TileHead but not TileServer type, so if a directory was created for one TileServer and then you switch to another one no directory will be created for later TileServer because information about creating the dir was already in TileManager::dirs_.

Initially TileManager::dirs_ was created to save some time in the process of directory creation every time, but no profiling was done and it was only a guess. For now it's easier to remove TileManager::dirs_ completely and create directory every time it's needed. Which means moving prepareDir call from TileManager::requestTiles to TileManager::Session::onRead.

Also document relative classes:

• TileServerBase
• TileServerOSM
• TileServer2GIS
• TileServerFactory

Not every tile server provides tiles for every zoom level from 0 to 19. Sometimes the server may respond with empty file which will be cached (good), send to the requester (good) and processed by if (bad). Check size of the image prior to processing and if it's zero length just ignore. Otherwise the app crashes.

• use FreeType library
• no font settings for now
• use one single free font, include it in the project

After installing to CMAKE_INSTALL_PREFIX the library shall be discoverable in other CMake projects via CMAKE_PREFIX_PATH variable analysis.

Currently Renderer is tightly coupled with DataKeeper and Viewport. Projector instance is a child of DataKeeper. For new modules there is always a question where they should belong and sometimes it's not an easy one to answer. To decouple modules signal-slot concept can be used. Following issue #21 Boost.Signal2 must be used. Architecture must be the following:

• Modules knows nothing of each other
• Each module has public API including signals that describe module's features
• Each module must protect its thread-sensitive data
• GlobeViewer knows about every module and create their instances
• GlobeViewer defines signal-slot connections (immediately after module creation)

This issue must be resolved ASAP.

DataKeeper always sends true and MapGenerator always sends false. There's no need for them to have any parameters. It can be handled at GlobeViewer::Impl level. It can help to rename signal to "mapNotReady" for MapGenerator. Documentation must reflect the change.

Let's make it happen on key 'B' for now.

Boost.Signal2 is easier to use and provides some sort of implementation of Observer pattern. Plus it work well in multi-threaded environment.

All future connections between application parts (modules) shall be implemented as Boost.Signal2.

Without waiting for every request tile has been downloaded (or gotten from cache). It can partially solve #31.

Describe how using boost.asio helps keeping all OpenGL calls in the same thread.

For some weird reason GlobeViewer instance is called globalViewer. Must be renamed to globeViewer.

The mouse movement is currently used to pan the view. Rotating the Globe would be more frequent than panning. Suggest to use simple mouse move to rotate and mouse move with SHIFT modifier to pan.

Need to fix prior to closing #13.

The closer viewer to the Globe the more sensitive the zoom shall be. Far away it can move fast. There shall be a map to reflect this behaviour.

Might be useful after playing with panning and zooming too recklessly.

If the cursor is out of the Globe projection do nothing, otherwise rotate the Globe so that the point under cursor become the new projection center.

Currently resizing of the window is happening around the context center: what was in the center before resizing will stay in the center after. It's good for viewing the globe after going full screen. However, sometimes it's not the best option and there should be a choice for the user to pick a point in the client area (OpenGL context) to resize around. The most commonly option would probably be the top left corner.

To display map tiles it will require new shader and some GL variables.

#26 is essentially done, however the result is unacceptably slow and the app is almost unusable.

To fix this there should be a compromise between speed and visuals. For now delayed map rendering will be enough. It means upon changing the view or rotating the Globe rendering of the map will stop until getting new calculations of tile texture and corresponding vertices array. So there may (and probably will) be time when user will see no map tiles and will be moving "blindly". At least it will allow keep fast rotating and moving speed.

• determine screen resolution
• make window dimensions equal to 80-90% of that values
• place window in screen center
• create OpenGL context
• fill the whole window with some colour (not white)

It's too uncomfortable right now to surf the Globe, every movement causes map disappearance and redrawing in milliseconds (when tiles are cached). There's no need to hide the map every time. It's ok if you move or zoom and tile become a bit small or large for a moment and then be replaced by "the right ones". However it's still better to hide map during rotation of the Globe.

Tiles are at https://tileN.maps.2gis.com/tiles?x=X&y=Y&z=Z,
where N - number of mirror [0,4] and X,Y,Z - tile coordinates provided by user

GlobeViewer is already a fantastic software and it would be awesome if distance measuring feature is added to the project.

Meaning OpenGL context within window. If it's not handled properly while the window resized, the context will be stretched which is wrong.

Some tiles from 2Gis, for instance https://tile2.maps.2gis.com/tiles?x=16&y=10&z=5, has 4 channels when processed by stbi_load_from_memory, hence following memcpy calls are wrong. Need to take into account images may have different number of channels.

Currently TileManager will not send tiles in case one of the requested tiles was not downloaded. This prevents further work, no new map updates will be provided and the app must be restarted to get it working properly.

Should have retry counter and even if reaches zero and give error all other tile must be sent. It's better to have gaps in map then no map at all.

Class must find visible tiles, request them from TileManager and compose new texture to send to GlobeViewer to manage (texture must be updated in the same thread where OpenGL was initialized).

• use proj4 library
• draw lines with predefined colour and 10 degree steps

For this to be done the following script should suffice:

• command to shift projection
• projection center changes
• the whole wire-frame model recalculated