void onKeyPress(int _key) { switch (_key) { case KEY_ZOOM_IN: Tangram::handlePinchGesture(0.0,0.0,0.5,0.0); break; case KEY_ZOOM_OUT: Tangram::handlePinchGesture(0.0,0.0,2.0,0.0); break; case KEY_UP: Tangram::handlePanGesture(0.0,0.0,0.0,100.0); break; case KEY_DOWN: Tangram::handlePanGesture(0.0,0.0,0.0,-100.0); break; case KEY_LEFT: Tangram::handlePanGesture(0.0,0.0,100.0,0.0); break; case KEY_RIGHT: Tangram::handlePanGesture(0.0,0.0,-100.0,0.0); break; case KEY_ESC: bUpdate = false; break; default: logMsg(" -> %i\n",_key); } requestRender(); }
void setPosition(double _lon, double _lat) { glm::dvec2 meters = m_view->getMapProjection().LonLatToMeters({ _lon, _lat}); m_view->setPosition(meters.x, meters.y); requestRender(); }
void handleRotateGesture(float _posX, float _posY, float _radians) { m_view->screenToGroundPlane(_posX, _posY); m_view->orbit(_posX, _posY, _radians); requestRender(); }
void setZoomNow(float _z) { m_view->setZoom(_z); m_inputHandler->cancelFling(); requestRender(); }
bool DataSource::loadTileData(const TileID& _tileID, TileManager& _tileManager) { bool success = true; // Begin optimistically if (hasTileData(_tileID)) { _tileManager.addToWorkerQueue(m_tileStore[_tileID], _tileID, this); return success; } std::string url; constructURL(_tileID, url); success = startUrlRequest(url, [=,&_tileManager](std::vector<char>&& _rawData) { // _tileManager is captured here by reference, since its lifetime is the entire program lifetime, // but _tileID has to be captured by copy since it is a temporary stack object _tileManager.addToWorkerQueue(std::move(_rawData), _tileID, this); requestRender(); }); return success; }
void RenderController::_syncAndRender() { WallToWallChannel& wallChannel = _window.getWallChannel(); auto versionCheckFunc = std::bind( &WallToWallChannel::checkVersion, &wallChannel, std::placeholders::_1 ); _syncQuit.sync( versionCheckFunc ); if( _syncQuit.get( )) { killTimer( _renderTimer ); killTimer( _stopRenderingDelayTimer ); _window.deleteLater(); return; } _synchronizeObjects( versionCheckFunc ); const bool grab = _syncScreenshot.get(); if( grab ) _syncScreenshot = SwapSyncObject<bool>{ false }; if( !_window.syncAndRender( grab ) && wallChannel.allReady( !_needRedraw )) { if( _stopRenderingDelayTimer == 0 ) _stopRenderingDelayTimer = startTimer( 5000 /*ms*/ ); } else requestRender(); _needRedraw = false; }
int notify(int n, void *p) { Q_UNUSED(p); if( !n || n&LH_NOTE_MEM ) requestRender(); return LH_NOTE_MEM; }
int LH_MonitoringBar::notify(int n, void *p) { Q_UNUSED(p); if(!n || n&LH_NOTE_SECOND) requestRender(); return LH_Bar::notify(n,p) | LH_NOTE_SECOND; }
void IVtkAdaptorService::swapping() throw(fwTools::Failed) { m_connections->disconnect(); m_connections->connect(this->getObject(), this->getSptr(), this->getObjSrvConnections()); doSwap(); requestRender(); }
void InputHandler::onGesture() { m_gestureOccured = true; setVelocity(0.f, { 0.f, 0.f }); requestRender(); }
void IVtkAdaptorService::stopping() throw(fwTools::Failed) { /// Stop observation m_connections->disconnect(); doStop(); requestRender(); }
void onMouseDrag(float _x, float _y, int _button) { if( _button == 1 ){ Tangram::handlePanGesture( _x-getMouseVelX()*1.0, _y+getMouseVelY()*1.0, _x, _y); } else if( _button == 2 ){ if ( getKeyPressed() == 'r') { float scale = -0.05; float rot = atan2(getMouseVelY(),getMouseVelX()); if( _x < getWindowWidth()/2.0 ) { scale *= -1.0; } Tangram::handleRotateGesture(getWindowWidth()/2.0, getWindowHeight()/2.0, rot*scale); } else if ( getKeyPressed() == 't') { Tangram::handleShoveGesture(getMouseVelY()*0.005); } else { Tangram::handlePinchGesture(getWindowWidth()/2.0, getWindowHeight()/2.0, 1.0 + getMouseVelY()*0.001, 0.f); } } requestRender(); }
void setPositionNow(double _lon, double _lat) { glm::dvec2 meters = m_view->getMapProjection().LonLatToMeters({ _lon, _lat}); m_view->setPosition(meters.x, meters.y); m_inputHandler->cancelFling(); requestRender(); }
void clearDataSource(DataSource& _source, bool _data, bool _tiles) { if (!m_tileManager) { return; } std::lock_guard<std::mutex> lock(m_tilesMutex); if (_tiles) { m_tileManager->clearTileSet(_source.id()); } if (_data) { _source.clearData(); } requestRender(); }
void handlePanGesture(float _startX, float _startY, float _endX, float _endY) { m_view->screenToGroundPlane(_startX, _startY); m_view->screenToGroundPlane(_endX, _endY); m_view->translate(_startX - _endX, _startY - _endY); requestRender(); }
void IVtkAdaptorService::starting() throw(fwTools::Failed) { /// Install observation m_connections->connect(this->getObject(), this->getSptr(), this->getObjSrvConnections()); assert( m_renderService.lock() ); doStart(); requestRender(); }
void handleTapGesture(float _posX, float _posY) { float viewCenterX = 0.5f * m_view->getWidth(); float viewCenterY = 0.5f * m_view->getHeight(); m_view->screenToGroundPlane(viewCenterX, viewCenterY); m_view->screenToGroundPlane(_posX, _posY); m_view->translate((_posX - viewCenterX), (_posY - viewCenterY)); requestRender(); }
void TileWorker::processTileData(std::unique_ptr<TileTask> _task, const std::vector<std::unique_ptr<Style>>& _styles, const View& _view) { m_task = std::move(_task); m_free = false; m_finished = false; m_aborted = false; m_future = std::async(std::launch::async, [&]() { const TileID& tileID = m_task->tileID; DataSource* dataSource = m_task->source; auto tile = std::shared_ptr<MapTile>(new MapTile(tileID, _view.getMapProjection())); std::shared_ptr<TileData> tileData; if (m_task->parsedTileData) { // Data has already been parsed! tileData = m_task->parsedTileData; } else { // Data needs to be parsed tileData = dataSource->parse(*tile, m_task->rawTileData); // Cache parsed data with the original data source dataSource->setTileData(tileID, tileData); } tile->update(0, _view); //Process data for all styles for(const auto& style : _styles) { if(m_aborted) { m_finished = true; return std::move(tile); } if(tileData) { style->addData(*tileData, *tile, _view.getMapProjection()); } } m_finished = true; requestRender(); // Return finished tile return std::move(tile); }); }
void handlePinchGesture(float _posX, float _posY, float _scale) { float viewCenterX = 0.5f * m_view->getWidth(); float viewCenterY = 0.5f * m_view->getHeight(); m_view->screenToGroundPlane(viewCenterX, viewCenterY); m_view->screenToGroundPlane(_posX, _posY); m_view->translate((_posX - viewCenterX)*(1-1/_scale), (_posY - viewCenterY)*(1-1/_scale)); static float invLog2 = 1 / log(2); m_view->zoom(log(_scale) * invLog2); requestRender(); }
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 operator()(std::string level, std::string message) { if(level == "Error"){ #ifndef NDEBUG LOGE("Error:\t%s", message.c_str()); #endif JNIEnv *env; if(gJavaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK || !gCallbackObject || (gJavaVM->AttachCurrentThread(&env, NULL)) < 0) return; jstring jstr = env->NewStringUTF(message.c_str()); jclass jClass = env->FindClass("org/geuz/onelab/Gmsh"); if(jClass == 0) return; jmethodID mid = env->GetMethodID(jClass, "ShowPopup", "(Ljava/lang/String;)V"); if (mid == 0) return; env->CallVoidMethod(gCallbackObject, mid, jstr); env->DeleteLocalRef(jstr); env->DeleteLocalRef(jClass); return; } else if(level == "Progress"){ JNIEnv *env; if(gJavaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK || !gCallbackObject || (gJavaVM->AttachCurrentThread(&env, NULL)) < 0) return; jstring jstr = env->NewStringUTF(message.c_str()); jclass jClass = env->FindClass("org/geuz/onelab/Gmsh"); if(jClass == 0) return; jmethodID mid = env->GetMethodID(jClass, "SetLoading", "(Ljava/lang/String;)V"); if (mid == 0) return; env->CallVoidMethod(gCallbackObject, mid, jstr); env->DeleteLocalRef(jstr); env->DeleteLocalRef(jClass); return; } else if(level == "RequestRender"){ requestRender(); return; } #ifndef NDEBUG LOGI("%s:\t%s", level.c_str(), message.c_str()); #endif }
void InputHandler::update(float _dt) { auto velocityPanPixels = m_view.pixelsPerMeter() / m_view.pixelScale() * m_velocityPan; bool isFlinging = glm::length(velocityPanPixels) > THRESHOLD_STOP_PAN || std::abs(m_velocityZoom) > THRESHOLD_STOP_ZOOM; if (isFlinging) { m_velocityPan -= _dt * DAMPING_PAN * m_velocityPan; m_view.translate(_dt * m_velocityPan.x, _dt * m_velocityPan.y); m_velocityZoom -= _dt * DAMPING_ZOOM * m_velocityZoom; m_view.zoom(m_velocityZoom * _dt); requestRender(); } }
void RenderController::timerEvent( QTimerEvent* qtEvent ) { if( qtEvent->timerId() == _renderTimer ) _syncAndRender(); else if( qtEvent->timerId() == _idleRedrawTimer ) requestRender(); else if( qtEvent->timerId() == _stopRenderingDelayTimer ) { killTimer( _renderTimer ); killTimer( _stopRenderingDelayTimer ); _renderTimer = 0; _stopRenderingDelayTimer = 0; // Redraw screen every minute so that the on-screen clock is up to date if( _idleRedrawTimer == 0 ) _idleRedrawTimer = startTimer( 60000 /*ms*/ ); } }
void LH_MonitoringDial::updateBounds() { bool ok; SensorGroup *group = this->selectedSensorGroup(&ok); qreal _max = setup_max_->value(); qreal _min = setup_min_->value(); bool minExists = false; bool maxExists = false; if(ok) { minExists = group->limits.minimum.exists; if(group->limits.minimum.exists) { _min = group->limits.minimum.value; setup_min_->setValue(_min); } maxExists = group->limits.maximum.exists; if(group->limits.maximum.exists) { _max = group->limits.maximum.value; setup_max_->setValue(_max); } } setMax(_max); setMin(_min); //qDebug() << "Min: " << ok << "; minExists: " << minExists << "; min=" << _min << "; min_val():" << min_val() << "; setup_min_:" << setup_min_->value() << "; actual=set:" << (setup_min_->value() == min_val()); //qDebug() << "Max: " << ok << "; maxExists: " << maxExists << "; max=" << _max << "; max_val():" << max_val() << "; setup_max_:" << setup_max_->value() << "; actual=set:" << (setup_max_->value() == max_val()); bool _visible = (!minExists || setup_min_->value() == min_val()) && (!maxExists || setup_max_->value() == max_val()); setup_min_->setVisible(_visible); setup_max_->setVisible(_visible); setup_minmax_hr_->setVisible(_visible); requestRender(); }
void runOnMainLoop(std::function<void()> _task) { std::lock_guard<std::mutex> lock(m_tasksMutex); m_tasks.emplace(std::move(_task)); requestRender(); }
void setCameraType(int _type) { m_view->setCameraType(static_cast<CameraType>(_type)); requestRender(); }
void setEase(EaseField _f, Ease _e) { m_eases[static_cast<size_t>(_f)] = _e; requestRender(); }
void setTiltNow(float _radians) { m_view->setPitch(_radians); requestRender(); }
void setRotationNow(float _radians) { m_view->setRoll(_radians); requestRender(); }
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; }