void render() {
// Set up openGL for new frame
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Loop over all styles
for (const auto& style : m_scene->getStyles()) {
style->onBeginDrawFrame(m_view, m_scene);
// Loop over all tiles in m_tileSet
for (const auto& mapIDandTile : m_tileManager->getVisibleTiles()) {
const std::shared_ptr<MapTile>& tile = mapIDandTile.second;
if (tile->hasGeometry()) {
// Draw tile!
tile->draw(*style, *m_view);
}
}
style->onEndDrawFrame();
}
m_skybox->draw(*m_view);
while (Error::hadGlError("Tangram::render()")) {}
}
void render() {
// Set up openGL for new frame
RenderState::depthWrite(GL_TRUE);
auto& color = m_scene->background();
RenderState::clearColor(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
{
std::lock_guard<std::mutex> lock(m_tilesMutex);
// Loop over all styles
for (const auto& style : m_scene->styles()) {
// Set time uniforms style's shader programs
style->getShaderProgram()->setUniformf("u_time", g_time);
style->onBeginDrawFrame(*m_view, *m_scene);
// Loop over all tiles in m_tileSet
for (const auto& tile : m_tileManager->getVisibleTiles()) {
tile->draw(*style, *m_view);
}
style->onEndDrawFrame();
}
}
m_labels->drawDebug(*m_view);
while (Error::hadGlError("Tangram::render()")) {}
}
void update(float _dt) {
g_time += _dt;
if (m_view) {
m_view->update();
m_tileManager->updateTileSet();
if(m_view->changedOnLastUpdate() || m_tileManager->hasTileSetChanged() || Label::s_needUpdate) {
Label::s_needUpdate = false;
for (const auto& mapIDandTile : m_tileManager->getVisibleTiles()) {
const std::shared_ptr<MapTile>& tile = mapIDandTile.second;
tile->update(_dt, *m_view);
}
// update labels for specific style
for (const auto& style : m_scene->getStyles()) {
for (const auto& mapIDandTile : m_tileManager->getVisibleTiles()) {
const std::shared_ptr<MapTile>& tile = mapIDandTile.second;
tile->updateLabels(_dt, *style, *m_view);
}
}
// manage occlusions
m_labels->updateOcclusions();
for (const auto& style : m_scene->getStyles()) {
for (const auto& mapIDandTile : m_tileManager->getVisibleTiles()) {
const std::shared_ptr<MapTile>& tile = mapIDandTile.second;
tile->pushLabelTransforms(*style, m_labels);
}
}
}
if (Label::s_needUpdate) {
requestRender();
}
}
if(m_scene) {
// Update lights and styles
}
}
void update(float _dt) {
g_time += _dt;
for (auto& ease : m_eases) {
if (!ease.finished()) { ease.update(_dt); }
}
m_inputHandler->update(_dt);
m_view->update();
{
std::lock_guard<std::mutex> lock(m_tilesMutex);
ViewState viewState {
m_view->getMapProjection(),
m_view->changedOnLastUpdate(),
glm::dvec2{m_view->getPosition().x, -m_view->getPosition().y },
m_view->getZoom()
};
m_tileManager->updateTileSets(viewState, m_view->getVisibleTiles());
bool updateLabels = m_labels->needUpdate();
auto& tiles = m_tileManager->getVisibleTiles();
if (m_view->changedOnLastUpdate() || m_tileManager->hasTileSetChanged()) {
for (const auto& tile : tiles) {
tile->update(_dt, *m_view);
}
updateLabels = true;
}
if (updateLabels) {
auto& cache = m_tileManager->getTileCache();
m_labels->update(*m_view, _dt, m_scene->styles(), tiles, cache);
}
bool animated = false;
for (const auto& style : m_scene->styles()) {
if (style->isAnimated()) {
animated = true;
break;
}
}
if (animated != isContinuousRendering()) {
setContinuousRendering(animated);
}
}
}
void render() {
FrameInfo::beginFrame();
// Invalidate render states for new frame
if (!g_cacheGlState) {
RenderState::invalidate();
}
// Set up openGL for new frame
RenderState::depthWrite(GL_TRUE);
auto& color = m_scene->background();
RenderState::clearColor(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
GL_CHECK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
for (const auto& style : m_scene->styles()) {
style->onBeginFrame();
}
{
std::lock_guard<std::mutex> lock(m_tilesMutex);
// Loop over all styles
for (const auto& style : m_scene->styles()) {
style->onBeginDrawFrame(*m_view, *m_scene);
// Loop over all tiles in m_tileSet
for (const auto& tile : m_tileManager->getVisibleTiles()) {
style->draw(*tile);
}
style->onEndDrawFrame();
}
}
m_labels->drawDebug(*m_view);
FrameInfo::draw(*m_view, *m_tileManager);
}
void update(float _dt) {
g_time += _dt;
m_inputHandler->update(_dt);
m_view->update();
{
std::lock_guard<std::mutex> lock(m_tilesMutex);
m_tileManager->updateTileSets();
if (m_view->changedOnLastUpdate() || m_tileManager->hasTileSetChanged() || m_labels->needUpdate()) {
auto& tiles = m_tileManager->getVisibleTiles();
for (const auto& tile : tiles) {
tile->update(_dt, *m_view);
}
m_labels->update(*m_view, _dt, m_scene->styles(), tiles);
}
bool animated = false;
for (const auto& style : m_scene->styles()) {
if (style->isAnimated()) {
animated = true;
break;
}
}
if (animated != isContinuousRendering()) {
setContinuousRendering(animated);
}
}
}
const std::vector<TouchItem>& pickFeaturesAt(float _x, float _y) {
return m_labels->getFeaturesAtPoint(*m_view, 0, m_scene->styles(),
m_tileManager->getVisibleTiles(),
_x, _y);
}
bool update(float _dt) {
FrameInfo::beginUpdate();
g_time += _dt;
bool viewComplete = true;
for (auto& ease : m_eases) {
if (!ease.finished()) {
ease.update(_dt);
viewComplete = false;
}
}
size_t nTasks = 0;
{
std::lock_guard<std::mutex> lock(m_tasksMutex);
nTasks = m_tasks.size();
}
while (nTasks-- > 0) {
std::function<void()> task;
{
std::lock_guard<std::mutex> lock(m_tasksMutex);
task = m_tasks.front();
m_tasks.pop();
}
task();
}
m_inputHandler->update(_dt);
m_view->update();
for (const auto& style : m_scene->styles()) {
style->onBeginUpdate();
}
{
std::lock_guard<std::mutex> lock(m_tilesMutex);
ViewState viewState {
m_view->getMapProjection(),
m_view->changedOnLastUpdate(),
glm::dvec2{m_view->getPosition().x, -m_view->getPosition().y },
m_view->getZoom()
};
m_tileManager->updateTileSets(viewState, m_view->getVisibleTiles());
auto& tiles = m_tileManager->getVisibleTiles();
if (m_view->changedOnLastUpdate() ||
m_tileManager->hasTileSetChanged()) {
for (const auto& tile : tiles) {
tile->update(_dt, *m_view);
}
m_labels->updateLabelSet(*m_view, _dt, m_scene->styles(), tiles,
m_tileManager->getTileCache());
} else {
m_labels->updateLabels(*m_view, _dt, m_scene->styles(), tiles);
}
}
FrameInfo::endUpdate();
bool viewChanged = m_view->changedOnLastUpdate();
bool tilesChanged = m_tileManager->hasTileSetChanged();
bool tilesLoading = m_tileManager->hasLoadingTiles();
bool labelsNeedUpdate = m_labels->needUpdate();
bool resourceLoading = (m_scene->m_resourceLoad > 0);
bool nextScene = bool(m_nextScene);
if (viewChanged || tilesChanged || tilesLoading || labelsNeedUpdate || resourceLoading || nextScene) {
viewComplete = false;
}
// Request for render if labels are in fading in/out states
if (m_labels->needUpdate()) { requestRender(); }
return viewComplete;
}
void render() {
clock_t start, end;
if (Tangram::getDebugFlag(Tangram::DebugFlags::tangram_infos)) {
start = clock();
}
// Set up openGL for new frame
RenderState::depthWrite(GL_TRUE);
auto& color = m_scene->background();
RenderState::clearColor(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
{
std::lock_guard<std::mutex> lock(m_tilesMutex);
// Loop over all styles
for (const auto& style : m_scene->styles()) {
// Set time uniforms style's shader programs
style->getShaderProgram()->setUniformf("u_time", g_time);
style->onBeginDrawFrame(*m_view, *m_scene);
// Loop over all tiles in m_tileSet
for (const auto& tile : m_tileManager->getVisibleTiles()) {
tile->draw(*style, *m_view);
}
style->onEndDrawFrame();
}
}
m_labels->drawDebug(*m_view);
if (Tangram::getDebugFlag(Tangram::DebugFlags::tangram_infos)) {
// Force opengl to finish commands (for accurate frame time)
glFinish();
end = clock();
static int cpt = 0;
static float totaltime = 0;
static float time = 0.f;
// Only compute average frame time every 60 frames
if (cpt++ > 60) {
time = totaltime / float(cpt);
totaltime = 0.f;
cpt = 0;
}
totaltime += (float(end - start) / CLOCKS_PER_SEC) * 1000.f;
std::vector<std::string> debuginfos;
debuginfos.push_back("zoom:" + std::to_string(m_view->getZoom()));
debuginfos.push_back("pos:" + std::to_string(m_view->getPosition().x) + "/"
+ std::to_string(m_view->getPosition().y));
debuginfos.push_back("visible tiles:"
+ std::to_string(m_tileManager->getVisibleTiles().size()));
debuginfos.push_back("tile cache size:"
+ std::to_string(m_tileManager->getTileCache()->getMemoryUsage() / 1024) + "kb");
debuginfos.push_back("avg frame render time:" + std::to_string(time) + "ms");
size_t memused = 0;
for (const auto& tile : m_tileManager->getVisibleTiles()) {
memused += tile->getMemoryUsage();
}
debuginfos.push_back("tile size:" + std::to_string(memused / 1024) + "kb");
debuginfos.push_back("number of styles:"+ std::to_string(m_scene->styles().size()));
TextDisplay::Instance().draw(debuginfos);
}
while (Error::hadGlError("Tangram::render()")) {}
}
