void Load()
{
LOG(LDEBUG, ("Reading of classificator started"));
Platform & p = GetPlatform();
MapStyle const originMapStyle = GetStyleReader().GetCurrentStyle();
for (size_t i = 0; i < MapStyleCount; ++i)
{
MapStyle const mapStyle = static_cast<MapStyle>(i);
// Read the merged style only if it was requested.
if (mapStyle != MapStyleMerged || originMapStyle == MapStyleMerged)
{
GetStyleReader().SetCurrentStyle(mapStyle);
ReadCommon(p.GetReader("classificator.txt"),
p.GetReader("types.txt"));
drule::LoadRules();
}
}
GetStyleReader().SetCurrentStyle(originMapStyle);
LOG(LDEBUG, ("Reading of classificator finished"));
}
void Arrow3d::Render(ScreenBase const & screen, int zoomLevel, ref_ptr<dp::GpuProgramManager> mng)
{
// Unbind current VAO, because glVertexAttributePointer and glEnableVertexAttribute can affect it.
if (dp::GLExtensionsList::Instance().IsSupported(dp::GLExtensionsList::VertexArrayObject))
GLFunctions::glBindVertexArray(0);
if (!m_isInitialized)
{
Build();
m_isInitialized = true;
}
// Render shadow.
if (screen.isPerspective())
{
ref_ptr<dp::GpuProgram> shadowProgram = mng->GetProgram(gpu::ARROW_3D_SHADOW_PROGRAM);
RenderArrow(screen, shadowProgram, dp::Color(60, 60, 60, 60), 0.05f, false /* hasNormals */);
}
// Render arrow.
ref_ptr<dp::GpuProgram> arrowProgram = mng->GetProgram(gpu::ARROW_3D_PROGRAM);
dp::Color const color = df::GetColorConstant(GetStyleReader().GetCurrentStyle(),
m_obsoletePosition ? df::Arrow3DObsolete : df::Arrow3D);
RenderArrow(screen, arrowProgram, color, 0.0f, true /* hasNormals */);
arrowProgram->Unbind();
GLFunctions::glBindBuffer(0, gl_const::GLArrayBuffer);
}
void MyPosition::CacheAccuracySector(ref_ptr<dp::TextureManager> mng)
{
int const TriangleCount = 40;
int const VertexCount = 3 * TriangleCount;
float const etalonSector = math::twicePi / static_cast<double>(TriangleCount);
dp::TextureManager::ColorRegion color;
mng->GetColorRegion(df::GetColorConstant(GetStyleReader().GetCurrentStyle(), df::MyPositionAccuracy), color);
glsl::vec2 colorCoord = glsl::ToVec2(color.GetTexRect().Center());
buffer_vector<Vertex, TriangleCount> buffer;
glsl::vec2 startNormal(0.0f, 1.0f);
for (size_t i = 0; i < TriangleCount + 1; ++i)
{
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);
state.SetColorTexture(color.GetTexture());
{
dp::Batcher batcher(TriangleCount * dp::Batcher::IndexPerTriangle, VertexCount);
dp::SessionGuard guard(batcher, [this](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
{
drape_ptr<dp::RenderBucket> bucket = move(b);
ASSERT(bucket->GetOverlayHandlesCount() == 0, ());
m_nodes.emplace_back(state, bucket->MoveBuffer());
m_parts[MY_POSITION_ACCURACY].second = m_nodes.size() - 1;
});
dp::AttributeProvider provider(1 /*stream count*/, VertexCount);
provider.InitStream(0 /*stream index*/, GetBindingInfo(), make_ref(buffer.data()));
m_parts[MY_POSITION_ACCURACY].first = batcher.InsertTriangleList(state, make_ref(&provider), nullptr);
ASSERT(m_parts[MY_POSITION_ACCURACY].first.IsValid(), ());
}
int main(int argc, char ** argv)
{
google::SetUsageMessage(
"Takes OSM XML data from stdin and creates data and index files in several passes.");
google::ParseCommandLineFlags(&argc, &argv, true);
Platform & pl = GetPlatform();
if (!FLAGS_user_resource_path.empty())
pl.SetResourceDir(FLAGS_user_resource_path);
string const path =
FLAGS_data_path.empty() ? pl.WritableDir() : my::AddSlashIfNeeded(FLAGS_data_path);
feature::GenerateInfo genInfo;
genInfo.m_intermediateDir = FLAGS_intermediate_data_path.empty() ? path
: my::AddSlashIfNeeded(FLAGS_intermediate_data_path);
genInfo.m_targetDir = genInfo.m_tmpDir = path;
/// @todo Probably, it's better to add separate option for .mwm.tmp files.
if (!FLAGS_intermediate_data_path.empty())
{
string const tmpPath = genInfo.m_intermediateDir + "tmp" + my::GetNativeSeparator();
if (pl.MkDir(tmpPath) != Platform::ERR_UNKNOWN)
genInfo.m_tmpDir = tmpPath;
}
genInfo.m_osmFileName = FLAGS_osm_file_name;
genInfo.m_failOnCoasts = FLAGS_fail_on_coasts;
genInfo.m_preloadCache = FLAGS_preload_cache;
genInfo.m_bookingDatafileName = FLAGS_booking_data;
genInfo.m_bookingReferenceDir = FLAGS_booking_reference_path;
genInfo.m_versionDate = static_cast<uint32_t>(FLAGS_planet_version);
if (!FLAGS_node_storage.empty())
genInfo.SetNodeStorageType(FLAGS_node_storage);
if (!FLAGS_osm_file_type.empty())
genInfo.SetOsmFileType(FLAGS_osm_file_type);
// Generate intermediate files.
if (FLAGS_preprocess)
{
LOG(LINFO, ("Generating intermediate data ...."));
if (!GenerateIntermediateData(genInfo))
{
return -1;
}
}
// Use merged style.
GetStyleReader().SetCurrentStyle(MapStyleMerged);
// Load classificator only when necessary.
if (FLAGS_make_coasts || FLAGS_generate_features || FLAGS_generate_geometry ||
FLAGS_generate_index || FLAGS_generate_search_index || FLAGS_calc_statistics ||
FLAGS_type_statistics || FLAGS_dump_types || FLAGS_dump_prefixes ||
FLAGS_dump_feature_names != "" || FLAGS_check_mwm)
{
classificator::Load();
classif().SortClassificator();
}
// Generate dat file.
if (FLAGS_generate_features || FLAGS_make_coasts)
{
LOG(LINFO, ("Generating final data ..."));
genInfo.m_splitByPolygons = FLAGS_split_by_polygons;
genInfo.m_createWorld = FLAGS_generate_world;
genInfo.m_makeCoasts = FLAGS_make_coasts;
genInfo.m_emitCoasts = FLAGS_emit_coasts;
genInfo.m_fileName = FLAGS_output;
genInfo.m_genAddresses = FLAGS_generate_addresses_file;
if (!GenerateFeatures(genInfo))
return -1;
if (FLAGS_generate_world)
{
genInfo.m_bucketNames.push_back(WORLD_FILE_NAME);
genInfo.m_bucketNames.push_back(WORLD_COASTS_FILE_NAME);
}
}
else
{
if (!FLAGS_output.empty())
genInfo.m_bucketNames.push_back(FLAGS_output);
}
// Enumerate over all dat files that were created.
size_t const count = genInfo.m_bucketNames.size();
for (size_t i = 0; i < count; ++i)
{
string const & country = genInfo.m_bucketNames[i];
string const datFile = my::JoinFoldersToPath(path, country + DATA_FILE_EXTENSION);
if (FLAGS_generate_geometry)
{
int mapType = feature::DataHeader::country;
if (country == WORLD_FILE_NAME)
mapType = feature::DataHeader::world;
if (country == WORLD_COASTS_FILE_NAME)
mapType = feature::DataHeader::worldcoasts;
// On error move to the next bucket without index generation.
LOG(LINFO, ("Generating result features for", country));
if (!feature::GenerateFinalFeatures(genInfo, country, mapType))
continue;
LOG(LINFO, ("Generating offsets table for", datFile));
if (!feature::BuildOffsetsTable(datFile))
continue;
}
if (FLAGS_generate_index)
{
LOG(LINFO, ("Generating index for", datFile));
if (!indexer::BuildIndexFromDataFile(datFile, FLAGS_intermediate_data_path + country))
LOG(LCRITICAL, ("Error generating index."));
}
if (FLAGS_generate_search_index)
{
LOG(LINFO, ("Generating search index for", datFile));
if (!indexer::BuildSearchIndexFromDataFile(datFile, true))
LOG(LCRITICAL, ("Error generating search index."));
LOG(LINFO, ("Generating rank table for", datFile));
if (!search::RankTableBuilder::CreateIfNotExists(datFile))
LOG(LCRITICAL, ("Error generating rank table."));
}
}
string const datFile = path + FLAGS_output + DATA_FILE_EXTENSION;
if (FLAGS_calc_statistics)
{
LOG(LINFO, ("Calculating statistics for", datFile));
stats::FileContainerStatistic(datFile);
stats::FileContainerStatistic(datFile + ROUTING_FILE_EXTENSION);
stats::MapInfo info;
stats::CalcStatistic(datFile, info);
stats::PrintStatistic(info);
}
if (FLAGS_type_statistics)
{
LOG(LINFO, ("Calculating type statistics for", datFile));
stats::MapInfo info;
stats::CalcStatistic(datFile, info);
stats::PrintTypeStatistic(info);
}
if (FLAGS_dump_types)
feature::DumpTypes(datFile);
if (FLAGS_dump_prefixes)
feature::DumpPrefixes(datFile);
if (FLAGS_dump_search_tokens)
feature::DumpSearchTokens(datFile, 100 /* maxTokensToShow */);
if (FLAGS_dump_feature_names != "")
feature::DumpFeatureNames(datFile, FLAGS_dump_feature_names);
if (FLAGS_unpack_mwm)
UnpackMwm(datFile);
if (!FLAGS_delete_section.empty())
DeleteSection(datFile, FLAGS_delete_section);
if (FLAGS_generate_packed_borders)
borders::GeneratePackedBorders(path);
if (!FLAGS_unpack_borders.empty())
borders::UnpackBorders(path, FLAGS_unpack_borders);
if (FLAGS_check_mwm)
check_model::ReadFeatures(datFile);
if (!FLAGS_osrm_file_name.empty() && FLAGS_make_routing)
routing::BuildRoutingIndex(path, FLAGS_output, FLAGS_osrm_file_name);
if (!FLAGS_osrm_file_name.empty() && FLAGS_make_cross_section)
routing::BuildCrossRoutingIndex(path, FLAGS_output, FLAGS_osrm_file_name);
return 0;
}
