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;
}
