From bd43816060025d165d387d25e3a6114fa03121f4 Mon Sep 17 00:00:00 2001 From: Ylva Selling Date: Thu, 3 Mar 2022 12:10:41 -0500 Subject: [PATCH] Pull request fix requested changes --- .../rendering/screenspacerenderable.h | 2 +- .../skybrowser/include/screenspaceskytarget.h | 4 +- .../skybrowser/include/targetbrowserpair.h | 14 +- modules/skybrowser/include/wwtcommunicator.h | 4 +- modules/skybrowser/include/wwtdatahandler.h | 12 +- modules/skybrowser/skybrowsermodule_lua.inl | 2 +- .../skybrowser/src/screenspaceskybrowser.cpp | 11 +- .../skybrowser/src/screenspaceskytarget.cpp | 582 +++++++++-------- modules/skybrowser/src/targetbrowserpair.cpp | 593 +++++++++--------- modules/skybrowser/src/utility.cpp | 15 +- modules/skybrowser/src/wwtcommunicator.cpp | 16 +- modules/skybrowser/src/wwtdatahandler.cpp | 103 +-- .../webbrowser/include/screenspacebrowser.h | 4 - src/rendering/renderengine.cpp | 1 - src/rendering/screenspacerenderable.cpp | 35 +- 15 files changed, 693 insertions(+), 705 deletions(-) diff --git a/include/openspace/rendering/screenspacerenderable.h b/include/openspace/rendering/screenspacerenderable.h index 8fb13795f8..690e6371fe 100644 --- a/include/openspace/rendering/screenspacerenderable.h +++ b/include/openspace/rendering/screenspacerenderable.h @@ -80,7 +80,7 @@ public: glm::vec2 screenSpaceDimensions(); glm::vec2 upperRightCornerScreenSpace(); glm::vec2 lowerLeftCornerScreenSpace(); - bool intersection(glm::vec2 coord); + bool isIntersecting(glm::vec2 coord); void translate(glm::vec2 translation, glm::vec2 position); void setCartesianPosition(const glm::vec3& position); void setRaeFromCartesianPosition(const glm::vec3& position); diff --git a/modules/skybrowser/include/screenspaceskytarget.h b/modules/skybrowser/include/screenspaceskytarget.h index 866a4d9869..e826c1d0f0 100644 --- a/modules/skybrowser/include/screenspaceskytarget.h +++ b/modules/skybrowser/include/screenspaceskytarget.h @@ -78,8 +78,8 @@ public: void startAnimation(glm::dvec3 end, bool shouldLockAfter = true); void incrementallyAnimateToCoordinate(float deltaTime); // Display - void highlight(glm::ivec3 addition); - void removeHighlight(glm::ivec3 removal); + void highlight(const glm::ivec3& addition); + void removeHighlight(const glm::ivec3& removal); private: // Properties diff --git a/modules/skybrowser/include/targetbrowserpair.h b/modules/skybrowser/include/targetbrowserpair.h index 5fe396cfa8..bcd5ee4d9c 100644 --- a/modules/skybrowser/include/targetbrowserpair.h +++ b/modules/skybrowser/include/targetbrowserpair.h @@ -46,17 +46,17 @@ public: // Target & Browser void initialize(); // Highlighting - void removeHighlight(glm::ivec3 color); - void highlight(glm::ivec3 color); + void removeHighlight(const glm::ivec3& color); + void highlight(const glm::ivec3& color); // Animation void startAnimation(glm::dvec3 coordsEnd, float fovEnd, bool shouldLockAfter = true); void incrementallyAnimateToCoordinate(double deltaTime); void incrementallyFade(float goalState, float fadeTime, float deltaTime); // Mouse interaction - bool checkMouseIntersection(glm::vec2 mousePosition); - glm::vec2 selectedScreenSpacePosition(); - bool isBrowserSelected(); - bool isTargetSelected(); + bool checkMouseIntersection(const glm::vec2& mousePosition); + glm::vec2 selectedScreenSpacePosition() const; + bool isBrowserSelected() const; + bool isTargetSelected() const; void fineTuneTarget(const glm::vec2& start, const glm::vec2& translation); void translateSelected(const glm::vec2& start, const glm::vec2& translation); void synchronizeAim(); @@ -97,7 +97,7 @@ public: ScreenSpaceSkyTarget* getTarget(); ScreenSpaceSkyBrowser* getBrowser(); - const std::deque& getSelectedImages() const; + const std::deque& selectedImages() const; // WorldWide Telescope image handling void setImageOrder(int i, int order); diff --git a/modules/skybrowser/include/wwtcommunicator.h b/modules/skybrowser/include/wwtcommunicator.h index 7ef1c1adf8..e17ccf406f 100644 --- a/modules/skybrowser/include/wwtcommunicator.h +++ b/modules/skybrowser/include/wwtcommunicator.h @@ -67,9 +67,9 @@ public: void setEquatorialAim(glm::dvec2 equatorial); void setBorderColor(glm::ivec3 color); - void highlight(glm::ivec3 addition); + void highlight(const glm::ivec3& addition); // The removal parameter decides what will be removed from the border color - void removeHighlight(glm::ivec3 removal); + void removeHighlight(const glm::ivec3& removal); void updateBorderColor(); void updateAim(); diff --git a/modules/skybrowser/include/wwtdatahandler.h b/modules/skybrowser/include/wwtdatahandler.h index eaf32819b8..3351c63bd9 100644 --- a/modules/skybrowser/include/wwtdatahandler.h +++ b/modules/skybrowser/include/wwtdatahandler.h @@ -53,12 +53,12 @@ namespace openspace::wwt { namespace openspace { struct ImageData { - std::string name{ wwt::Undefined }; - std::string thumbnailUrl{ wwt::Undefined }; - std::string imageUrl{ wwt::Undefined }; - std::string credits{ wwt::Undefined }; - std::string creditsUrl{ wwt::Undefined }; - std::string collection{ wwt::Undefined }; + std::string name = wwt::Undefined; + std::string thumbnailUrl = wwt::Undefined; + std::string imageUrl = wwt::Undefined; + std::string credits = wwt::Undefined; + std::string creditsUrl = wwt::Undefined; + std::string collection = wwt::Undefined; bool hasCelestialCoords = false; float fov = 0.f; glm::dvec2 equatorialSpherical = glm::dvec2(0.0); diff --git a/modules/skybrowser/skybrowsermodule_lua.inl b/modules/skybrowser/skybrowsermodule_lua.inl index 08e062ec9b..ec5f88e080 100644 --- a/modules/skybrowser/skybrowsermodule_lua.inl +++ b/modules/skybrowser/skybrowsermodule_lua.inl @@ -327,7 +327,7 @@ int getTargetData(lua_State* L) { std::string id = pair->browserId(); // Convert deque to vector so ghoul can read it std::vector selectedImagesVector; - const std::deque selectedImages = pair->getSelectedImages(); + const std::deque selectedImages = pair->selectedImages(); std::for_each( selectedImages.begin(), selectedImages.end(), diff --git a/modules/skybrowser/src/screenspaceskybrowser.cpp b/modules/skybrowser/src/screenspaceskybrowser.cpp index fb9b142015..515e624d03 100644 --- a/modules/skybrowser/src/screenspaceskybrowser.cpp +++ b/modules/skybrowser/src/screenspaceskybrowser.cpp @@ -39,18 +39,17 @@ namespace { constexpr const char* _loggerCat = "ScreenSpaceSkyBrowser"; - constexpr const openspace::properties::Property::PropertyInfo AnimationSpeedInfo = - { + constexpr const openspace::properties::Property::PropertyInfo AnimationSpeedInfo = { "AnimationSpeed", "Field Of View Animation Speed", - "The factor which is multiplied with the animation of the field of view." + "A factor that determines the speed of the animation of the field of view. A " + "higher number for the factor means a faster speed." }; - constexpr const openspace::properties::Property::PropertyInfo TextureQualityInfo = - { + constexpr const openspace::properties::Property::PropertyInfo TextureQualityInfo = { "TextureQuality", "Quality of Texture", "A parameter to set the resolution of the texture. 1 is full resolution and " - "slower framerate. Lower value means lower resolution of texture and faster " + "slower frame rate. Lower value means lower resolution of texture and faster " "frame rate." }; diff --git a/modules/skybrowser/src/screenspaceskytarget.cpp b/modules/skybrowser/src/screenspaceskytarget.cpp index a07ea8bd6a..d76e6497cc 100644 --- a/modules/skybrowser/src/screenspaceskytarget.cpp +++ b/modules/skybrowser/src/screenspaceskytarget.cpp @@ -72,8 +72,8 @@ namespace { "AnimationThreshold", "Animation Threshold", "The threshold for when the target is determined to have appeared at its " - "destination. Angle in radians between the destination and the target position in" - "equatorial Cartesian coordinate system." + "destination. Angle in radians between the destination and the target position " + "in equatorial Cartesian coordinate system." }; constexpr const openspace::properties::Property::PropertyInfo LineWidthInfo = @@ -101,330 +101,326 @@ namespace { }; #include "screenspaceskytarget_codegen.cpp" - } //namespace namespace openspace { - ScreenSpaceSkyTarget::ScreenSpaceSkyTarget(const ghoul::Dictionary& dictionary) - : ScreenSpaceRenderable(dictionary) - , _showCrosshairThreshold(CrosshairThresholdInfo, 4.f, 0.1f, 70.f) - , _showRectangleThreshold(RectangleThresholdInfo, 2.f, 0.1f, 70.f) - , _stopAnimationThreshold(AnimationThresholdInfo, 0.0005, 0.0, 0.005) - , _animationSpeed(AnimationSpeedInfo, 5.0, 0.1, 10.0) - , _lineWidth(LineWidthInfo, 25.f, 1.f, 100.f) - , _borderColor(220, 220, 220) - { - // Handle target dimension property - const Parameters p = codegen::bake(dictionary); - _showCrosshairThreshold = p.crosshairThreshold.value_or(_showCrosshairThreshold); - _showRectangleThreshold = p.rectangleThreshold.value_or(_showRectangleThreshold); - _stopAnimationThreshold = p.crosshairThreshold.value_or(_stopAnimationThreshold); - _animationSpeed = p.animationSpeed.value_or(_animationSpeed); +ScreenSpaceSkyTarget::ScreenSpaceSkyTarget(const ghoul::Dictionary& dictionary) + : ScreenSpaceRenderable(dictionary) + , _showCrosshairThreshold(CrosshairThresholdInfo, 4.f, 0.1f, 70.f) + , _showRectangleThreshold(RectangleThresholdInfo, 2.f, 0.1f, 70.f) + , _stopAnimationThreshold(AnimationThresholdInfo, 0.0005, 0.0, 0.005) + , _animationSpeed(AnimationSpeedInfo, 5.0, 0.1, 10.0) + , _lineWidth(LineWidthInfo, 25.f, 1.f, 100.f) + , _borderColor(220, 220, 220) +{ + // Handle target dimension property + const Parameters p = codegen::bake(dictionary); + _showCrosshairThreshold = p.crosshairThreshold.value_or(_showCrosshairThreshold); + _showRectangleThreshold = p.rectangleThreshold.value_or(_showRectangleThreshold); + _stopAnimationThreshold = p.crosshairThreshold.value_or(_stopAnimationThreshold); + _animationSpeed = p.animationSpeed.value_or(_animationSpeed); - addProperty(_showCrosshairThreshold); - addProperty(_showRectangleThreshold); - addProperty(_stopAnimationThreshold); - addProperty(_animationSpeed); - addProperty(_lineWidth); - - // Set a unique identifier - std::string identifier; - if (dictionary.hasValue(KeyIdentifier)) { - identifier = dictionary.value(KeyIdentifier); - } - else { - identifier = "ScreenSpaceSkyTarget"; - } - identifier = makeUniqueIdentifier(identifier); - setIdentifier(identifier); - - // Set the position to screen space z - _cartesianPosition = glm::dvec3( - _cartesianPosition.value().x, - _cartesianPosition.value().y, - skybrowser::ScreenSpaceZ - ); + addProperty(_showCrosshairThreshold); + addProperty(_showRectangleThreshold); + addProperty(_stopAnimationThreshold); + addProperty(_animationSpeed); + addProperty(_lineWidth); + // Set a unique identifier + std::string identifier; + if (dictionary.hasValue(KeyIdentifier)) { + identifier = dictionary.value(KeyIdentifier); } - - ScreenSpaceSkyTarget::~ScreenSpaceSkyTarget() { - SkyBrowserModule* module = global::moduleEngine->module(); - - if (module && module->getPair(identifier())) { - module->removeTargetBrowserPair(identifier()); - } + else { + identifier = "ScreenSpaceSkyTarget"; } + identifier = makeUniqueIdentifier(identifier); + setIdentifier(identifier); - // Pure virtual in the screen space renderable class and hence must be defined - void ScreenSpaceSkyTarget::bindTexture() {} + // Set the position to screen space z + _cartesianPosition = glm::dvec3( + _cartesianPosition.value().x, + _cartesianPosition.value().y, + skybrowser::ScreenSpaceZ + ); +} - bool ScreenSpaceSkyTarget::isReady() const { - return _shader != nullptr; +ScreenSpaceSkyTarget::~ScreenSpaceSkyTarget() { + SkyBrowserModule* module = global::moduleEngine->module(); + + if (module && module->getPair(identifier())) { + module->removeTargetBrowserPair(identifier()); } +} - bool ScreenSpaceSkyTarget::initializeGL() { - glGenVertexArrays(1, &_vertexArray); - glGenBuffers(1, &_vertexBuffer); - createShaders(); +// Pure virtual in the screen space renderable class and hence must be defined +void ScreenSpaceSkyTarget::bindTexture() {} - return isReady(); - } +bool ScreenSpaceSkyTarget::isReady() const { + return _shader != nullptr; +} - bool ScreenSpaceSkyTarget::deinitializeGL() { - return ScreenSpaceRenderable::deinitializeGL(); - } +bool ScreenSpaceSkyTarget::initializeGL() { + glGenVertexArrays(1, &_vertexArray); + glGenBuffers(1, &_vertexBuffer); + createShaders(); - glm::mat4 ScreenSpaceSkyTarget::scaleMatrix() { - // To ensure the plane has the right ratio - // The _scale us how much of the windows height the browser covers: e.g. a browser - // that covers 0.25 of the height of the window will have scale = 0.25 - glm::vec2 floatObjectSize = glm::abs(_objectSize); - float ratio = floatObjectSize.x / floatObjectSize.y; + return isReady(); +} - glm::mat4 scale = glm::scale( - glm::mat4(1.f), - glm::vec3(ratio * _scale, _scale, 1.f) - ); +bool ScreenSpaceSkyTarget::deinitializeGL() { + return ScreenSpaceRenderable::deinitializeGL(); +} - return scale; - } +glm::mat4 ScreenSpaceSkyTarget::scaleMatrix() { + // To ensure the plane has the right ratio + // The _scale us how much of the windows height the browser covers: e.g. a browser + // that covers 0.25 of the height of the window will have scale = 0.25 + glm::vec2 floatObjectSize = glm::abs(_objectSize); + float ratio = floatObjectSize.x / floatObjectSize.y; + + glm::mat4 scale = glm::scale( + glm::mat4(1.f), + glm::vec3(ratio * _scale, _scale, 1.f) + ); + + return scale; +} - void ScreenSpaceSkyTarget::createShaders() { - _shader = global::renderEngine->buildRenderProgram( - "ScreenSpaceProgram", - absPath("${MODULE_SKYBROWSER}/shaders/target_vs.glsl"), - absPath("${MODULE_SKYBROWSER}/shaders/target_fs.glsl") - ); +void ScreenSpaceSkyTarget::createShaders() { + _shader = global::renderEngine->buildRenderProgram( + "ScreenSpaceProgram", + absPath("${MODULE_SKYBROWSER}/shaders/target_vs.glsl"), + absPath("${MODULE_SKYBROWSER}/shaders/target_fs.glsl") + ); - ghoul::opengl::updateUniformLocations(*_shader, _uniformCache, UniformNames); + ghoul::opengl::updateUniformLocations(*_shader, _uniformCache, UniformNames); +} - } +void ScreenSpaceSkyTarget::setColor(glm::ivec3 color) { + _borderColor = std::move(color); +} - void ScreenSpaceSkyTarget::setColor(glm::ivec3 color) { - _borderColor = std::move(color); - } +glm::ivec3 ScreenSpaceSkyTarget::borderColor() const { + return _borderColor; +} - glm::ivec3 ScreenSpaceSkyTarget::borderColor() const { - return _borderColor; - } - - void ScreenSpaceSkyTarget::render() { - bool showCrosshair = _verticalFov < _showCrosshairThreshold; - bool showRectangle = _verticalFov > _showRectangleThreshold; +void ScreenSpaceSkyTarget::render() { + bool showCrosshair = _verticalFov < _showCrosshairThreshold; + bool showRectangle = _verticalFov > _showRectangleThreshold; - glm::vec4 color = { glm::vec3(_borderColor) / 255.f, _opacity.value() }; - glm::mat4 modelTransform = globalRotationMatrix() * translationMatrix() * - localRotationMatrix() * scaleMatrix(); - float lineWidth = (_lineWidth * 0.0001f) / _scale.value(); + glm::vec4 color = { glm::vec3(_borderColor) / 255.f, _opacity.value() }; + glm::mat4 modelTransform = globalRotationMatrix() * translationMatrix() * + localRotationMatrix() * scaleMatrix(); + float lineWidth = (_lineWidth * 0.0001f) / _scale.value(); - glDisable(GL_CULL_FACE); + glDisable(GL_CULL_FACE); - _shader->activate(); - _shader->setUniform(_uniformCache.showCrosshair, showCrosshair); - _shader->setUniform(_uniformCache.showRectangle, showRectangle); - _shader->setUniform(_uniformCache.lineWidth, lineWidth); - _shader->setUniform(_uniformCache.dimensions, glm::vec2(_objectSize)); - _shader->setUniform(_uniformCache.modelTransform, modelTransform); - _shader->setUniform(_uniformCache.lineColor, color); - _shader->setUniform( - _uniformCache.viewProj, - global::renderEngine->scene()->camera()->viewProjectionMatrix() + _shader->activate(); + _shader->setUniform(_uniformCache.showCrosshair, showCrosshair); + _shader->setUniform(_uniformCache.showRectangle, showRectangle); + _shader->setUniform(_uniformCache.lineWidth, lineWidth); + _shader->setUniform(_uniformCache.dimensions, glm::vec2(_objectSize)); + _shader->setUniform(_uniformCache.modelTransform, modelTransform); + _shader->setUniform(_uniformCache.lineColor, color); + _shader->setUniform( + _uniformCache.viewProj, + global::renderEngine->scene()->camera()->viewProjectionMatrix() + ); + + glBindVertexArray(rendering::helper::vertexObjects.square.vao); + glDrawArrays(GL_TRIANGLES, 0, 6); + + glEnable(GL_CULL_FACE); + + _shader->deactivate(); +} + +void ScreenSpaceSkyTarget::update() { + if (_isLocked) { + glm::dvec3 localCamera = skybrowser::equatorialToLocalCamera( + _lockedCoordinates ); - glBindVertexArray(rendering::helper::vertexObjects.square.vao); - glDrawArrays(GL_TRIANGLES, 0, 6); - - glEnable(GL_CULL_FACE); - - _shader->deactivate(); - } - - void ScreenSpaceSkyTarget::update() { - if (_isLocked) { - glm::dvec3 localCamera = skybrowser::equatorialToLocalCamera( - _lockedCoordinates - ); - - if (_useRadiusAzimuthElevation) { - // Keep the set radius - glm::vec3 position = _raePosition.value().x * glm::vec3(localCamera); - _raePosition = cartesianToRae(position); - } - else { - _cartesianPosition = skybrowser::localCameraToScreenSpace3d( - localCamera - ); - } - - } - } - - void ScreenSpaceSkyTarget::setDimensions(glm::vec2 dimensions) { - // To avoid flooring of the size of the target, multiply by factor of 100 - // Object size is really the pixel size so this calculation is not exact - _objectSize = glm::ivec2(dimensions * 100.f); - } - - glm::dvec3 ScreenSpaceSkyTarget::directionGalactic() const { - glm::vec3 localCamera = _cartesianPosition.value(); - - if (_useRadiusAzimuthElevation) { - localCamera = raeToCartesian(_raePosition.value()); - } - - glm::dmat4 rotation = glm::inverse( - global::navigationHandler->camera()->viewRotationMatrix() - ); - glm::dvec4 position = glm::dvec4(localCamera, 1.0); - - return glm::normalize(rotation * position); - } - - // Update the scale of the target (the height of the target in relation to the - // OpenSpace window) - void ScreenSpaceSkyTarget::setScaleFromVfov(float verticalFov) { - _verticalFov = verticalFov; - glm::dvec2 fovs = skybrowser::fovWindow(); - - // Cap the scale at small scales so it is still visible - float heightRatio = verticalFov / fovs.y; - float smallestHeightRatio = _showRectangleThreshold.value() / fovs.y; - - _scale = std::max(heightRatio, smallestHeightRatio); - } - - void ScreenSpaceSkyTarget::setFovFromScale() { - glm::dvec2 fovs = skybrowser::fovWindow(); - _verticalFov = _scale * fovs.y; - } - - bool ScreenSpaceSkyTarget::isLocked() const { - return _isLocked; - } - - bool ScreenSpaceSkyTarget::isAnimated() { - return _isAnimated; - } - - void ScreenSpaceSkyTarget::startAnimation(glm::dvec3 equatorialCoordsEnd, - bool shouldLockAfter) { - _animationStart = glm::normalize( - skybrowser::sphericalToCartesian(equatorialAim()) - ); - _animationEnd = glm::normalize(equatorialCoordsEnd); - _shouldLockAfterAnimation = shouldLockAfter; - _isAnimated = true; - _isLocked = false; - } - - void ScreenSpaceSkyTarget::incrementallyAnimateToCoordinate(float deltaTime) { - // At fps that are too low, the animation stops working. Just place target instead - bool fpsTooLow = deltaTime > DeltaTimeThreshold; - // Find smallest angle between the two vectors - double smallestAngle = skybrowser::angleBetweenVectors(_animationStart, - _animationEnd); - bool hasArrived = smallestAngle < _stopAnimationThreshold; - - // Only keep animating when target is not at goal position - if (!hasArrived && !fpsTooLow) { - glm::dmat4 rotMat = skybrowser::incrementalAnimationMatrix( - _animationStart, - _animationEnd, - deltaTime, - _animationSpeed - ); - - // Rotate target direction - glm::dvec3 equatorial = glm::dvec3(rotMat * glm::dvec4(_animationStart, 1.0)); - glm::dvec3 localCamera = skybrowser::equatorialToLocalCamera(equatorial); - // Convert to screen space - if (_useRadiusAzimuthElevation) { - // Keep the radius - glm::vec3 position = _raePosition.value().x * glm::vec3(localCamera); - _raePosition = cartesianToRae(position); - } - else { - _cartesianPosition = skybrowser::localCameraToScreenSpace3d(localCamera); - } - - // Update position - glm::dvec3 cartesian = skybrowser::sphericalToCartesian(equatorialAim()); - _animationStart = glm::normalize(cartesian); - } - else { - // Set the exact target position - glm::dvec3 localCamera = skybrowser::equatorialToLocalCamera(_animationEnd); - - if (_useRadiusAzimuthElevation) { - glm::vec3 position = _raePosition.value().x * glm::vec3(localCamera); - _raePosition = cartesianToRae(position); - } - else { - _cartesianPosition = skybrowser::localCameraToScreenSpace3d(localCamera); - } - - _isAnimated = false; - // Lock target when it first arrives to the position - setLock(_shouldLockAfterAnimation); - } - } - - glm::dvec2 ScreenSpaceSkyTarget::equatorialAim() const { - glm::dvec3 cartesian; - // Get the local camera coordinates of the target - if (_useRadiusAzimuthElevation) { - cartesian = raeToCartesian(_raePosition.value()); - glm::dvec3 equatorial = skybrowser::localCameraToEquatorial(cartesian); - return skybrowser::cartesianToSpherical(equatorial); - - } - else { - cartesian = skybrowser::localCameraToEquatorial(_cartesianPosition.value()); - return skybrowser::cartesianToSpherical(cartesian); - } - } - - void ScreenSpaceSkyTarget::highlight(glm::ivec3 addition) { - _borderColor += addition; - } - - void ScreenSpaceSkyTarget::removeHighlight(glm::ivec3 removal) { - _borderColor -= removal; - } - - float ScreenSpaceSkyTarget::opacity() const { - return _opacity; - } - - glm::dvec2 ScreenSpaceSkyTarget::lockedCoordinates() const { - return skybrowser::cartesianToSpherical(_lockedCoordinates); - } - - void ScreenSpaceSkyTarget::setOpacity(float opacity) { - _opacity = opacity; - } - - void ScreenSpaceSkyTarget::setLock(bool isLocked) { - _isLocked = isLocked; - if (_isLocked) { - _lockedCoordinates = skybrowser::sphericalToCartesian(equatorialAim()); - } - } - - void ScreenSpaceSkyTarget::setEquatorialAim(const glm::dvec2& aim) { - _isAnimated = false; - _isLocked = false; - - glm::dvec3 cartesianAim = skybrowser::sphericalToCartesian(aim); - glm::dvec3 localCamera = skybrowser::equatorialToLocalCamera(cartesianAim); if (_useRadiusAzimuthElevation) { // Keep the set radius glm::vec3 position = _raePosition.value().x * glm::vec3(localCamera); _raePosition = cartesianToRae(position); } else { - _cartesianPosition = skybrowser::localCameraToScreenSpace3d(localCamera); + _cartesianPosition = skybrowser::localCameraToScreenSpace3d( + localCamera + ); } } } + +void ScreenSpaceSkyTarget::setDimensions(glm::vec2 dimensions) { + // To avoid flooring of the size of the target, multiply by factor of 100 + // Object size is really the pixel size so this calculation is not exact + _objectSize = glm::ivec2(dimensions * 100.f); +} + +glm::dvec3 ScreenSpaceSkyTarget::directionGalactic() const { + glm::vec3 localCamera = _cartesianPosition.value(); + + if (_useRadiusAzimuthElevation) { + localCamera = raeToCartesian(_raePosition.value()); + } + + glm::dmat4 rotation = glm::inverse( + global::navigationHandler->camera()->viewRotationMatrix() + ); + glm::dvec4 position = glm::dvec4(localCamera, 1.0); + + return glm::normalize(rotation * position); +} + +// Update the scale of the target (the height of the target in relation to the +// OpenSpace window) +void ScreenSpaceSkyTarget::setScaleFromVfov(float verticalFov) { + _verticalFov = verticalFov; + glm::dvec2 fovs = skybrowser::fovWindow(); + + // Cap the scale at small scales so it is still visible + float heightRatio = verticalFov / fovs.y; + float smallestHeightRatio = _showRectangleThreshold.value() / fovs.y; + + _scale = std::max(heightRatio, smallestHeightRatio); +} + +void ScreenSpaceSkyTarget::setFovFromScale() { + glm::dvec2 fovs = skybrowser::fovWindow(); + _verticalFov = _scale * fovs.y; +} + +bool ScreenSpaceSkyTarget::isLocked() const { + return _isLocked; +} + +bool ScreenSpaceSkyTarget::isAnimated() { + return _isAnimated; +} + +void ScreenSpaceSkyTarget::startAnimation(glm::dvec3 equatorialCoordsEnd, + bool shouldLockAfter) +{ + _animationStart = glm::normalize( + skybrowser::sphericalToCartesian(equatorialAim()) + ); + _animationEnd = glm::normalize(equatorialCoordsEnd); + _shouldLockAfterAnimation = shouldLockAfter; + _isAnimated = true; + _isLocked = false; +} + +void ScreenSpaceSkyTarget::incrementallyAnimateToCoordinate(float deltaTime) { + // At fps that are too low, the animation stops working. Just place target instead + bool fpsTooLow = deltaTime > DeltaTimeThreshold; + // Find smallest angle between the two vectors + double smallestAngle = skybrowser::angleBetweenVectors(_animationStart, + _animationEnd); + bool hasArrived = smallestAngle < _stopAnimationThreshold; + + // Only keep animating when target is not at goal position + if (!hasArrived && !fpsTooLow) { + glm::dmat4 rotMat = skybrowser::incrementalAnimationMatrix( + _animationStart, + _animationEnd, + deltaTime, + _animationSpeed + ); + + // Rotate target direction + glm::dvec3 equatorial = glm::dvec3(rotMat * glm::dvec4(_animationStart, 1.0)); + glm::dvec3 localCamera = skybrowser::equatorialToLocalCamera(equatorial); + // Convert to screen space + if (_useRadiusAzimuthElevation) { + // Keep the radius + glm::vec3 position = _raePosition.value().x * glm::vec3(localCamera); + _raePosition = cartesianToRae(position); + } + else { + _cartesianPosition = skybrowser::localCameraToScreenSpace3d(localCamera); + } + + // Update position + glm::dvec3 cartesian = skybrowser::sphericalToCartesian(equatorialAim()); + _animationStart = glm::normalize(cartesian); + } + else { + // Set the exact target position + glm::dvec3 localCamera = skybrowser::equatorialToLocalCamera(_animationEnd); + + if (_useRadiusAzimuthElevation) { + glm::vec3 position = _raePosition.value().x * glm::vec3(localCamera); + _raePosition = cartesianToRae(position); + } + else { + _cartesianPosition = skybrowser::localCameraToScreenSpace3d(localCamera); + } + + _isAnimated = false; + // Lock target when it first arrives to the position + setLock(_shouldLockAfterAnimation); + } +} + +glm::dvec2 ScreenSpaceSkyTarget::equatorialAim() const { + glm::dvec3 cartesian; + // Get the local camera coordinates of the target + if (_useRadiusAzimuthElevation) { + cartesian = raeToCartesian(_raePosition.value()); + glm::dvec3 equatorial = skybrowser::localCameraToEquatorial(cartesian); + return skybrowser::cartesianToSpherical(equatorial); + } + else { + cartesian = skybrowser::localCameraToEquatorial(_cartesianPosition.value()); + return skybrowser::cartesianToSpherical(cartesian); + } +} + +void ScreenSpaceSkyTarget::highlight(const glm::ivec3& addition) { + _borderColor += addition; +} + +void ScreenSpaceSkyTarget::removeHighlight(const glm::ivec3& removal) { + _borderColor -= removal; +} + +float ScreenSpaceSkyTarget::opacity() const { + return _opacity; +} + +glm::dvec2 ScreenSpaceSkyTarget::lockedCoordinates() const { + return skybrowser::cartesianToSpherical(_lockedCoordinates); +} + +void ScreenSpaceSkyTarget::setOpacity(float opacity) { + _opacity = opacity; +} + +void ScreenSpaceSkyTarget::setLock(bool isLocked) { + _isLocked = isLocked; + if (_isLocked) { + _lockedCoordinates = skybrowser::sphericalToCartesian(equatorialAim()); + } +} + +void ScreenSpaceSkyTarget::setEquatorialAim(const glm::dvec2& aim) { + _isAnimated = false; + _isLocked = false; + + glm::dvec3 cartesianAim = skybrowser::sphericalToCartesian(aim); + glm::dvec3 localCamera = skybrowser::equatorialToLocalCamera(cartesianAim); + if (_useRadiusAzimuthElevation) { + // Keep the set radius + glm::vec3 position = _raePosition.value().x * glm::vec3(localCamera); + _raePosition = cartesianToRae(position); + } + else { + _cartesianPosition = skybrowser::localCameraToScreenSpace3d(localCamera); + } +} +} // namespace openspace diff --git a/modules/skybrowser/src/targetbrowserpair.cpp b/modules/skybrowser/src/targetbrowserpair.cpp index 965091c62b..9554abc23f 100644 --- a/modules/skybrowser/src/targetbrowserpair.cpp +++ b/modules/skybrowser/src/targetbrowserpair.cpp @@ -37,348 +37,349 @@ namespace openspace { - TargetBrowserPair::TargetBrowserPair(ScreenSpaceSkyBrowser* browser, - ScreenSpaceSkyTarget* target) - : _target(target), _browser(browser) - { - ghoul_assert(browser != nullptr, "Sky browser is null pointer!"); - ghoul_assert(target != nullptr, "Sky target is null pointer!"); - } +TargetBrowserPair::TargetBrowserPair(ScreenSpaceSkyBrowser* browser, + ScreenSpaceSkyTarget* target) + : _target(target), _browser(browser) +{ + ghoul_assert(browser != nullptr, "Sky browser is null pointer!"); + ghoul_assert(target != nullptr, "Sky target is null pointer!"); +} - TargetBrowserPair& TargetBrowserPair::operator=(TargetBrowserPair other) { - std::swap(_target, other._target); - std::swap(_browser, other._browser); - return *this; - - } +TargetBrowserPair& TargetBrowserPair::operator=(TargetBrowserPair other) { + std::swap(_target, other._target); + std::swap(_browser, other._browser); + return *this; +} - void TargetBrowserPair::lock() { - _target->setLock(true); - } +void TargetBrowserPair::lock() { + _target->setLock(true); +} - void TargetBrowserPair::unlock() { - _target->setLock(false); - } +void TargetBrowserPair::unlock() { + _target->setLock(false); +} - void TargetBrowserPair::setImageOrder(int i, int order) { - _browser->setImageOrder(i, order); - } +void TargetBrowserPair::setImageOrder(int i, int order) { + _browser->setImageOrder(i, order); +} - void TargetBrowserPair::removeHighlight(glm::ivec3 color) { - _target->removeHighlight(color); - _browser->removeHighlight(color); - } +void TargetBrowserPair::removeHighlight(const glm::ivec3& color) { + _target->removeHighlight(color); + _browser->removeHighlight(color); +} - void TargetBrowserPair::highlight(glm::ivec3 color) { - _browser->highlight(color); - _target->highlight(color); - } +void TargetBrowserPair::highlight(const glm::ivec3& color) { + _browser->highlight(color); + _target->highlight(color); +} - bool TargetBrowserPair::isTargetFadeFinished(float goalState) const { - // Is fading finished? - float targetDiff = abs(_target->opacity() - goalState); +bool TargetBrowserPair::isTargetFadeFinished(float goalState) const { + float targetDiff = abs(_target->opacity() - goalState); - return targetDiff < FadeThreshold; + return targetDiff < FadeThreshold; +} + +bool TargetBrowserPair::isBrowserFadeFinished(float goalState) const { + float browserDiff = abs(_browser->opacity() - goalState); + return browserDiff < FadeThreshold; +} + +bool TargetBrowserPair::checkMouseIntersection(const glm::vec2& mousePosition) { + bool onBrowser = _browser->isIntersecting(mousePosition); + bool onTarget = _target->isIntersecting(mousePosition); + if (onBrowser) { + _selected = _browser; + _isSelectedBrowser = true; } - - bool TargetBrowserPair::isBrowserFadeFinished(float goalState) const { - float browserDiff = abs(_browser->opacity() - goalState); - return browserDiff < FadeThreshold; + else if (onTarget) { + _selected = _target; + _isSelectedBrowser = false; } - - bool TargetBrowserPair::checkMouseIntersection(glm::vec2 mousePosition) { - bool onBrowser = _browser->intersection(mousePosition); - bool onTarget = _target->intersection(mousePosition); - if (onBrowser) { - _selected = _browser; - _isSelectedBrowser = true; - } - else if (onTarget) { - _selected = _target; - _isSelectedBrowser = false; - } - else { - _selected = nullptr; - _isSelectedBrowser = false; - } - return onBrowser || onTarget; + else { + _selected = nullptr; + _isSelectedBrowser = false; } + return onBrowser || onTarget; +} - glm::vec2 TargetBrowserPair::selectedScreenSpacePosition() { - return _selected->screenSpacePosition(); - } +glm::vec2 TargetBrowserPair::selectedScreenSpacePosition() const { + return _selected->screenSpacePosition(); +} - bool TargetBrowserPair::isBrowserSelected() { - return _isSelectedBrowser; - } +bool TargetBrowserPair::isBrowserSelected() const { + return _isSelectedBrowser; +} - bool TargetBrowserPair::isTargetSelected() { - return _selected && !_isSelectedBrowser; - } +bool TargetBrowserPair::isTargetSelected() const { + return _selected && !_isSelectedBrowser; +} - void TargetBrowserPair::fineTuneTarget(const glm::vec2& start, - const glm::vec2& translation) - { - glm::vec2 fineTune = _browser->fineTuneVector(translation); +// The fine tune of the target is a way to "drag and drop" the target with right click +// drag on the sky browser window. This is to be able to drag the target around when it +// has a very small field of view +void TargetBrowserPair::fineTuneTarget(const glm::vec2& start, + const glm::vec2& translation) +{ + glm::vec2 fineTune = _browser->fineTuneVector(translation); + openspace::global::scriptEngine->queueScript( + "openspace.skybrowser.translateScreenSpaceRenderable(\"" + targetId() + "\"," + + std::to_string(start.x) + "," + std::to_string(start.y) + "," + + std::to_string(fineTune.x) + "," + std::to_string(fineTune.y) + ")", + scripting::ScriptEngine::RemoteScripting::Yes + ); +} + +void TargetBrowserPair::translateSelected(const glm::vec2& start, + const glm::vec2& trans) +{ + if (this && _selected) { + std::string id = _selected->identifier(); openspace::global::scriptEngine->queueScript( - "openspace.skybrowser.translateScreenSpaceRenderable(\"" + targetId() + "\"," + "openspace.skybrowser.translateScreenSpaceRenderable(\"" + id + "\"," + std::to_string(start.x) + "," + std::to_string(start.y) + "," - + std::to_string(fineTune.x) + "," + std::to_string(fineTune.y) + ")", + + std::to_string(trans.x) + "," + std::to_string(trans.y) + ")", scripting::ScriptEngine::RemoteScripting::Yes ); } +} - void TargetBrowserPair::translateSelected(const glm::vec2& start, - const glm::vec2& trans) - { - if (this && _selected) { - std::string id = _selected->identifier(); - openspace::global::scriptEngine->queueScript( - "openspace.skybrowser.translateScreenSpaceRenderable(\"" + id + "\"," - + std::to_string(start.x) + "," + std::to_string(start.y) + "," - + std::to_string(trans.x) + "," + std::to_string(trans.y) + ")", - scripting::ScriptEngine::RemoteScripting::Yes - ); +void TargetBrowserPair::synchronizeAim() { + if (!_target->isAnimated()) { + glm::dvec2 aim; + // To remove the lag effect when moving the camera while having a locked + // target, send the locked coordinates to wwt + if (_target->isLocked()) { + aim = _target->lockedCoordinates(); + } + else { + aim = _target->equatorialAim(); } - } - - void TargetBrowserPair::synchronizeAim() { - if (!_target->isAnimated()) { - glm::dvec2 aim; - // To remove the lag effect when moving the camera while having a locked - // target, send the locked coordinates to wwt - if (_target->isLocked()) { - aim = _target->lockedCoordinates(); - } - else { - aim = _target->equatorialAim(); - } - _browser->setEquatorialAim(aim); - _target->setScaleFromVfov(_browser->verticalFov()); - } - } - - void TargetBrowserPair::setEnabled(bool enable) { - _browser->setEnabled(enable); - _target->setEnabled(enable); - } - - bool TargetBrowserPair::isEnabled() const { - return _target->isEnabled() && _browser->isEnabled(); - } - - bool TargetBrowserPair::isLocked() const { - return _target->isLocked(); - } - - void TargetBrowserPair::initialize() { - _target->setColor(_browser->borderColor()); - _target->setDimensions(_browser->browserPixelDimensions()); - _target->setScaleFromVfov(_browser->verticalFov()); - _browser->updateBorderColor(); - } - - glm::ivec3 TargetBrowserPair::borderColor() const { - return _browser->borderColor(); - } - - glm::dvec2 TargetBrowserPair::targetDirectionEquatorial() const { - return _target->equatorialAim(); - } - - glm::dvec3 TargetBrowserPair::targetDirectionGalactic() const { - return _target->directionGalactic(); - } - - std::string TargetBrowserPair::browserGuiName() const { - return _browser->guiName(); - } - - std::string TargetBrowserPair::browserId() const { - return _browser->identifier(); - } - - std::string TargetBrowserPair::targetId() const { - return _target->identifier(); - } - - std::string TargetBrowserPair::selectedId() { - return _selected->identifier(); - } - - glm::vec2 TargetBrowserPair::size() const { - return _browser->size(); - } - - float TargetBrowserPair::verticalFov() const { - return _browser->verticalFov(); - } - - const std::deque& TargetBrowserPair::getSelectedImages() const { - return _browser->getSelectedImages(); - } - - void TargetBrowserPair::selectImage(const ImageData& image, int i) { - // Load image into browser - _browser->displayImage(image.imageUrl, i); - - // If the image has coordinates, move the target - if (image.hasCelestialCoords) { - - // Animate the target to the image coordinate position - unlock(); - startAnimation(image.equatorialCartesian, image.fov, true); - } - } - - void TargetBrowserPair::removeSelectedImage(int i) { - _browser->removeSelectedImage(i); - } - - void TargetBrowserPair::loadImageCollection(const std::string& collection) { - _browser->loadImageCollection(collection); - } - - void TargetBrowserPair::setImageOpacity(int i, float opacity) { - _browser->setImageOpacity(i, opacity); - } - - void TargetBrowserPair::hideChromeInterface(bool shouldHide) { - _browser->hideChromeInterface(shouldHide); - } - - void TargetBrowserPair::sendIdToBrowser() { - _browser->setIdInBrowser(); - } - - void TargetBrowserPair::updateBrowserSize() { - _browser->updateBrowserSize(); - } - - void TargetBrowserPair::setIsSyncedWithWwt(bool isSynced) { - _browser->setIsSyncedWithWwt(isSynced); - } - - void TargetBrowserPair::setVerticalFov(float vfov) { - _verticalFov = vfov; - _browser->setVerticalFov(vfov); - _target->setScaleFromVfov(vfov); - } - - void TargetBrowserPair::setEquatorialAim(const glm::dvec2& aim) { - _equatorialAim = aim; - _target->setEquatorialAim(aim); _browser->setEquatorialAim(aim); + _target->setScaleFromVfov(_browser->verticalFov()); } +} - void TargetBrowserPair::setBorderColor(const glm::ivec3& color) { - _borderColor = color; - _target->setColor(color); - _browser->setBorderColor(color); - } +void TargetBrowserPair::setEnabled(bool enable) { + _browser->setEnabled(enable); + _target->setEnabled(enable); +} - void TargetBrowserPair::setScreenSpaceSize(const glm::vec2& dimensions) { - _dimensions = dimensions; - _target->setDimensions(dimensions); - _browser->setScreenSpaceSize(dimensions); - } +bool TargetBrowserPair::isEnabled() const { + return _target->isEnabled() && _browser->isEnabled(); +} - void TargetBrowserPair::setVerticalFovWithScroll(float scroll) { - _browser->setVerticalFovWithScroll(scroll); - } +bool TargetBrowserPair::isLocked() const { + return _target->isLocked(); +} - void TargetBrowserPair::setSelectedWithId(const std::string& id) { - if (browserId() == id) { - _isSelectedBrowser = true; - _selected = _browser; - } - else if (targetId() == id) { - _isSelectedBrowser = false; - _selected = _target; - } - else { - _isSelectedBrowser = false; - _selected = nullptr; - } - } +void TargetBrowserPair::initialize() { + _target->setColor(_browser->borderColor()); + _target->setDimensions(_browser->browserPixelDimensions()); + _target->setScaleFromVfov(_browser->verticalFov()); + _browser->updateBorderColor(); +} - void TargetBrowserPair::incrementallyAnimateToCoordinate(double deltaTime) { - // Animate the target before the field of view starts to animate - if (_target->isAnimated()) { - _target->incrementallyAnimateToCoordinate(static_cast(deltaTime)); - } - else if (_browser->isAnimated()) { - _browser->incrementallyAnimateToFov(static_cast(deltaTime)); - } - } +glm::ivec3 TargetBrowserPair::borderColor() const { + return _browser->borderColor(); +} - void TargetBrowserPair::startAnimation(glm::dvec3 equatorialCoords, float fovEnd, - bool shouldLockAfter) - { - _target->startAnimation(equatorialCoords, shouldLockAfter); - _browser->startFovAnimation(fovEnd); - } +glm::dvec2 TargetBrowserPair::targetDirectionEquatorial() const { + return _target->equatorialAim(); +} - void TargetBrowserPair::centerTargetOnScreen() { - // Animate the target to the center of the screen +glm::dvec3 TargetBrowserPair::targetDirectionGalactic() const { + return _target->directionGalactic(); +} + +std::string TargetBrowserPair::browserGuiName() const { + return _browser->guiName(); +} + +std::string TargetBrowserPair::browserId() const { + return _browser->identifier(); +} + +std::string TargetBrowserPair::targetId() const { + return _target->identifier(); +} + +std::string TargetBrowserPair::selectedId() { + return _selected->identifier(); +} + +glm::vec2 TargetBrowserPair::size() const { + return _browser->size(); +} + +float TargetBrowserPair::verticalFov() const { + return _browser->verticalFov(); +} + +const std::deque& TargetBrowserPair::selectedImages() const { + return _browser->getSelectedImages(); +} + +void TargetBrowserPair::selectImage(const ImageData& image, int i) { + // Load image into browser + _browser->displayImage(image.imageUrl, i); + + // If the image has coordinates, move the target + if (image.hasCelestialCoords) { + + // Animate the target to the image coordinate position unlock(); - // Get camera direction in celestial spherical coordinates - glm::dvec3 viewDirection = skybrowser::cameraDirectionEquatorial(); - // Keep the current fov - float currentFov = verticalFov(); - startAnimation(viewDirection, currentFov, false); + startAnimation(image.equatorialCartesian, image.fov, true); } +} - bool TargetBrowserPair::hasFinishedFading(float goalState) const { - return isTargetFadeFinished(goalState) && isBrowserFadeFinished(goalState); +void TargetBrowserPair::removeSelectedImage(int i) { + _browser->removeSelectedImage(i); +} + +void TargetBrowserPair::loadImageCollection(const std::string& collection) { + _browser->loadImageCollection(collection); +} + +void TargetBrowserPair::setImageOpacity(int i, float opacity) { + _browser->setImageOpacity(i, opacity); +} + +void TargetBrowserPair::hideChromeInterface(bool shouldHide) { + _browser->hideChromeInterface(shouldHide); +} + +void TargetBrowserPair::sendIdToBrowser() { + _browser->setIdInBrowser(); +} + +void TargetBrowserPair::updateBrowserSize() { + _browser->updateBrowserSize(); +} + +void TargetBrowserPair::setIsSyncedWithWwt(bool isSynced) { + _browser->setIsSyncedWithWwt(isSynced); +} + +void TargetBrowserPair::setVerticalFov(float vfov) { + _verticalFov = vfov; + _browser->setVerticalFov(vfov); + _target->setScaleFromVfov(vfov); +} + +void TargetBrowserPair::setEquatorialAim(const glm::dvec2& aim) { + _equatorialAim = aim; + _target->setEquatorialAim(aim); + _browser->setEquatorialAim(aim); +} + +void TargetBrowserPair::setBorderColor(const glm::ivec3& color) { + _borderColor = color; + _target->setColor(color); + _browser->setBorderColor(color); +} + +void TargetBrowserPair::setScreenSpaceSize(const glm::vec2& dimensions) { + _dimensions = dimensions; + _target->setDimensions(dimensions); + _browser->setScreenSpaceSize(dimensions); +} + +void TargetBrowserPair::setVerticalFovWithScroll(float scroll) { + _browser->setVerticalFovWithScroll(scroll); +} + +void TargetBrowserPair::setSelectedWithId(const std::string& id) { + if (browserId() == id) { + _isSelectedBrowser = true; + _selected = _browser; } - - bool TargetBrowserPair::isFacingCamera() const { - return _browser->isFacingCamera() || _target->isFacingCamera(); + else if (targetId() == id) { + _isSelectedBrowser = false; + _selected = _target; } - - bool TargetBrowserPair::isUsingRadiusAzimuthElevation() const { - return _browser->isUsingRaeCoords() || _target->isUsingRaeCoords(); + else { + _isSelectedBrowser = false; + _selected = nullptr; } +} - ScreenSpaceSkyTarget* TargetBrowserPair::getTarget() { - return _target; +void TargetBrowserPair::incrementallyAnimateToCoordinate(double deltaTime) { + // Animate the target before the field of view starts to animate + if (_target->isAnimated()) { + _target->incrementallyAnimateToCoordinate(static_cast(deltaTime)); } - - ScreenSpaceSkyBrowser* TargetBrowserPair::getBrowser() { - return _browser; + else if (_browser->isAnimated()) { + _browser->incrementallyAnimateToFov(static_cast(deltaTime)); } +} - void TargetBrowserPair::incrementallyFade(float goalState, float fadeTime, - float deltaTime) - { - float opacityDelta = static_cast(deltaTime / fadeTime); - if (_target->opacity() > goalState) { - opacityDelta *= -1.f; - } +void TargetBrowserPair::startAnimation(glm::dvec3 equatorialCoords, float fovEnd, + bool shouldLockAfter) +{ + _target->startAnimation(equatorialCoords, shouldLockAfter); + _browser->startFovAnimation(fovEnd); +} + +void TargetBrowserPair::centerTargetOnScreen() { + // Animate the target to the center of the screen + unlock(); + // Get camera direction in celestial spherical coordinates + glm::dvec3 viewDirection = skybrowser::cameraDirectionEquatorial(); + // Keep the current fov + float currentFov = verticalFov(); + startAnimation(viewDirection, currentFov, false); +} + +bool TargetBrowserPair::hasFinishedFading(float goalState) const { + return isTargetFadeFinished(goalState) && isBrowserFadeFinished(goalState); +} + +bool TargetBrowserPair::isFacingCamera() const { + return _browser->isFacingCamera() || _target->isFacingCamera(); +} + +bool TargetBrowserPair::isUsingRadiusAzimuthElevation() const { + return _browser->isUsingRaeCoords() || _target->isUsingRaeCoords(); +} + +ScreenSpaceSkyTarget* TargetBrowserPair::getTarget() { + return _target; +} + +ScreenSpaceSkyBrowser* TargetBrowserPair::getBrowser() { + return _browser; +} + +void TargetBrowserPair::incrementallyFade(float goalState, float fadeTime, + float deltaTime) +{ + float opacityDelta = static_cast(deltaTime / fadeTime); + if (_target->opacity() > goalState) { + opacityDelta *= -1.f; + } - if (!isTargetFadeFinished(goalState)) { - _target->setOpacity(_target->opacity() + opacityDelta); - } - else { - _target->setOpacity(goalState); - } + if (!isTargetFadeFinished(goalState)) { + _target->setOpacity(_target->opacity() + opacityDelta); + } + else { + _target->setOpacity(goalState); + } - if (!isBrowserFadeFinished(goalState)) { - _browser->setOpacity(_browser->opacity() + opacityDelta); - } - else { - _browser->setOpacity(goalState); - } + if (!isBrowserFadeFinished(goalState)) { + _browser->setOpacity(_browser->opacity() + opacityDelta); } + else { + _browser->setOpacity(goalState); + } +} - bool operator==(const TargetBrowserPair& lhs, const TargetBrowserPair& rhs) { - return lhs._target == rhs._target && lhs._browser == rhs._browser; - } +bool operator==(const TargetBrowserPair& lhs, const TargetBrowserPair& rhs) { + return lhs._target == rhs._target && lhs._browser == rhs._browser; +} - bool operator!=(const TargetBrowserPair& lhs, const TargetBrowserPair& rhs) { - return !(lhs == rhs); - } +bool operator!=(const TargetBrowserPair& lhs, const TargetBrowserPair& rhs) { + return !(lhs == rhs); +} } // namespace openspace diff --git a/modules/skybrowser/src/utility.cpp b/modules/skybrowser/src/utility.cpp index c98260cdf1..3060b05497 100644 --- a/modules/skybrowser/src/utility.cpp +++ b/modules/skybrowser/src/utility.cpp @@ -34,7 +34,6 @@ namespace openspace::skybrowser { // Converts from spherical coordinates in the unit of degrees to cartesian coordianates glm::dvec3 sphericalToCartesian(const glm::dvec2& coords) { - glm::dvec2 coordsRadians = glm::radians(coords); glm::dvec3 cartesian = glm::dvec3( @@ -100,8 +99,7 @@ glm::dvec3 localCameraToEquatorial(const glm::dvec3& coords) { return skybrowser::galacticToEquatorial(galactic); } -glm::dvec3 equatorialToLocalCamera(const glm::dvec3& coords) -{ +glm::dvec3 equatorialToLocalCamera(const glm::dvec3& coords) { // Transform equatorial J2000 to galactic coord with infinite radius glm::dvec3 galactic = equatorialToGalactic(coords); glm::dvec3 localCamera = galacticToLocalCamera(galactic); @@ -161,7 +159,6 @@ bool isCoordinateInView(const glm::dvec3& equatorial) { bool isCoordInView = abs(coordsScreen.x) < r && abs(coordsScreen.y) < 1.f && coordsScreen.z < 0; - // If the coordinate is not in view, rotate camera return isCoordInView; } @@ -187,17 +184,15 @@ glm::dvec2 fovWindow() { return OpenSpaceFOV; } -double angleBetweenVectors(const glm::dvec3& start, const glm::dvec3& end) { - +double angleBetweenVectors(const glm::dvec3& start, const glm::dvec3& end) { // Find smallest angle between the two vectors double cos = glm::dot(start, end) / (glm::length(start) * glm::length(end)); return std::acos(cos); } -glm::dmat4 incrementalAnimationMatrix(const glm::dvec3& start, - const glm::dvec3& end, double deltaTime, - double speedFactor) { - +glm::dmat4 incrementalAnimationMatrix(const glm::dvec3& start, const glm::dvec3& end, + double deltaTime, double speedFactor) +{ double smallestAngle = angleBetweenVectors(start, end); // Calculate rotation this frame double rotationAngle = smallestAngle * deltaTime * speedFactor; diff --git a/modules/skybrowser/src/wwtcommunicator.cpp b/modules/skybrowser/src/wwtcommunicator.cpp index 4336074f47..6237f7e63b 100644 --- a/modules/skybrowser/src/wwtcommunicator.cpp +++ b/modules/skybrowser/src/wwtcommunicator.cpp @@ -99,11 +99,11 @@ void WwtCommunicator::setBorderColor(glm::ivec3 color) { _borderColorIsDirty = true; } -void WwtCommunicator::highlight(glm::ivec3 addition) { +void WwtCommunicator::highlight(const glm::ivec3& addition) { setWebpageBorderColor(_borderColor + addition); } -void WwtCommunicator::removeHighlight(glm::ivec3 removal) { +void WwtCommunicator::removeHighlight(const glm::ivec3& removal) { setWebpageBorderColor(_borderColor - removal); } @@ -221,12 +221,12 @@ float WwtCommunicator::verticalFov() const { // WWT messages ghoul::Dictionary WwtCommunicator::moveCameraMessage(const glm::dvec2& celestCoords, - double fov, double roll, - bool shouldMoveInstantly) { + double fov, double roll, + bool shouldMoveInstantly) +{ using namespace std::string_literals; ghoul::Dictionary msg; - // Create message msg.setValue("event", "center_on_coordinates"s); msg.setValue("ra", celestCoords.x); msg.setValue("dec", celestCoords.y); @@ -257,7 +257,8 @@ ghoul::Dictionary WwtCommunicator::setForegroundMessage(const std::string& name) } ghoul::Dictionary WwtCommunicator::addImageMessage(const std::string& id, - const std::string& url) { + const std::string& url) +{ using namespace std::string_literals; ghoul::Dictionary msg; msg.setValue("event", "image_layer_create"s); @@ -279,7 +280,8 @@ ghoul::Dictionary WwtCommunicator::removeImageMessage(const std::string& imageId } ghoul::Dictionary WwtCommunicator::setImageOpacityMessage(const std::string& imageId, - double opacity) { + double opacity) +{ using namespace std::string_literals; ghoul::Dictionary msg; msg.setValue("event", "image_layer_set"s); diff --git a/modules/skybrowser/src/wwtdatahandler.cpp b/modules/skybrowser/src/wwtdatahandler.cpp index 0f3d8944b7..7382a8a10f 100644 --- a/modules/skybrowser/src/wwtdatahandler.cpp +++ b/modules/skybrowser/src/wwtdatahandler.cpp @@ -40,16 +40,14 @@ namespace { namespace openspace { bool hasAttribute(const tinyxml2::XMLElement* element, const std::string_view& name) { - return element->FindAttribute(std::string(name).c_str()); + return element->FindAttribute(std::string(name).c_str()); } std::string attribute(const tinyxml2::XMLElement* element, const std::string& name) { if (hasAttribute(element, name)) { return element->FindAttribute(name.c_str())->Value(); } - else { - return wwt::Undefined; - } + return wwt::Undefined; } // Parsing and downloading of wtml files @@ -70,15 +68,26 @@ bool directoryExists(const std::filesystem::path& path) { std::string createSearchableString(std::string str) { // Remove white spaces and all special characters - str.erase(std::remove_if(str.begin(), str.end(), [](char c) { - const bool isNumberOrLetter = std::isdigit(c) || std::isalpha(c); - return !isNumberOrLetter; - }), - std::end(str)); + str.erase( + std::remove_if( + str.begin(), + str.end(), + [](char c) { + const bool isNumberOrLetter = std::isdigit(c) || std::isalpha(c); + return !isNumberOrLetter; + } + ), + str.end() + ); // Make the word lower case - std::transform(str.begin(), str.end(), str.begin(), [](char c) { - return std::tolower(c); - }); + std::transform( + str.begin(), + str.end(), + str.begin(), + [](char c) { + return std::tolower(c); + } + ); return str; } @@ -94,7 +103,6 @@ tinyxml2::XMLElement* getDirectChildNode(tinyxml2::XMLElement* node, tinyxml2::XMLElement* getChildNode(tinyxml2::XMLElement* node, const std::string& name) { - tinyxml2::XMLElement* child = node->FirstChildElement(); tinyxml2::XMLElement* imageSet = nullptr; @@ -122,9 +130,7 @@ std::string getChildNodeContentFromImageSet(tinyxml2::XMLElement* imageSet, if (imageSetChild && imageSetChild->GetText()) { return imageSetChild->GetText(); } - else { - return wwt::Undefined; - } + return wwt::Undefined; } std::string getUrlFromPlace(tinyxml2::XMLElement* place) { @@ -141,10 +147,8 @@ std::string getUrlFromPlace(tinyxml2::XMLElement* place) { if (imageSet) { return getChildNodeContentFromImageSet(imageSet, wwt::ThumbnailUrl); } - else { - // If it doesn't contain an ImageSet, it doesn't have an url - return wwt::Undefined; - } + // If it doesn't contain an ImageSet, it doesn't have an url + return wwt::Undefined; } @@ -152,7 +156,6 @@ void parseWtmlsFromDisc(std::vector& _xmls, const std::filesystem::path& directory) { for (const auto& entry : std::filesystem::directory_iterator(directory)) { - tinyxml2::XMLDocument* document = new tinyxml2::XMLDocument(); std::string path = entry.path().u8string(); tinyxml2::XMLError successCode = document->LoadFile(path.c_str()); @@ -179,7 +182,9 @@ bool downloadAndParseWtmlFilesFromUrl(std::vector& _xmls // Download file from url std::filesystem::path file = directory.string() + fileName + ".aspx"; if (!downloadFile(url, file)) { - LINFO("Couldn't download file " + url + " to directory " + directory.string()); + LINFO( + fmt::format("Couldn't download file '{}' to directory '{}'", url, directory) + ); return false; } @@ -199,13 +204,11 @@ bool downloadAndParseWtmlFilesFromUrl(std::vector& _xmls if (!folderExists || folderContainNoUrls) { _xmls.push_back(doc); LINFO("Saving " + url); - return true; } // Iterate through all the folders in the XML file while (element && std::string(element->Value()) == wwt::Folder) { - // If folder contains urls, download and parse those urls if (hasAttribute(element, wwt::Url) && hasAttribute(element, wwt::Name)) { std::string url = attribute(element, wwt::Url); @@ -223,8 +226,8 @@ WwtDataHandler::~WwtDataHandler() { } void WwtDataHandler::loadImages(const std::string& root, - const std::filesystem::path& directory) { - + const std::filesystem::path& directory) +{ // Collect the wtml files, either by reading from disc or from a url if (directoryExists(directory)) { parseWtmlsFromDisc(_xmls, directory); @@ -243,36 +246,37 @@ void WwtDataHandler::loadImages(const std::string& root, } // Sort images in alphabetical order - std::sort(_images.begin(), _images.end(), [](ImageData& a, ImageData& b) { - // If the first character in the names are lowercase, make it upper case - if (std::islower(a.name[0])) { - // convert string to upper case - a.name[0] = ::toupper(a.name[0]); + std::sort( + _images.begin(), + _images.end(), + [](ImageData& a, ImageData& b) { + // If the first character in the names are lowercase, make it upper case + if (std::islower(a.name[0])) { + // convert string to upper case + a.name[0] = ::toupper(a.name[0]); + } + if (std::islower(b.name[0])) { + b.name[0] = ::toupper(b.name[0]); + } + return a.name < b.name; } - if (std::islower(b.name[0])) { - b.name[0] = ::toupper(b.name[0]); - } - return a.name < b.name; - }); + ); - LINFO("Loaded " + std::to_string(_images.size()) + " WorldWide Telescope " - "images."); + LINFO(fmt::format("Loaded {} WorldWide Telescope images.", _images.size())); } -int WwtDataHandler::nLoadedImages() const -{ +int WwtDataHandler::nLoadedImages() const { return _images.size(); } -const ImageData& WwtDataHandler::getImage(const int i) const -{ +const ImageData& WwtDataHandler::getImage(const int i) const { ghoul_assert(i < _images.size(), "Index outside of image vector boundaries!"); return _images[i]; } -void WwtDataHandler::saveImageFromNode(tinyxml2::XMLElement* node, - std::string collection) { - +void WwtDataHandler::saveImageFromNode(tinyxml2::XMLElement* node, + std::string collection) +{ // Collect the image set of the node. The structure is different depending on if // it is a Place or an ImageSet std::string thumbnailUrl = { wwt::Undefined }; @@ -282,7 +286,7 @@ void WwtDataHandler::saveImageFromNode(tinyxml2::XMLElement* node, if (type == wwt::ImageSet) { thumbnailUrl = getChildNodeContentFromImageSet(node, wwt::ThumbnailUrl); imageSet = node; - } // Place + } else if (type == wwt::Place) { thumbnailUrl = getUrlFromPlace(node); imageSet = getChildNode(node, wwt::ImageSet); @@ -325,7 +329,7 @@ void WwtDataHandler::saveImageFromNode(tinyxml2::XMLElement* node, } // Collect field of view. The WWT definition of ZoomLevel is: VFOV = ZoomLevel / 6 - float fov{ 0.f }; + float fov = 0.f; if (hasAttribute(node, wwt::ZoomLevel)) { fov = std::stof(attribute(node, wwt::ZoomLevel)) / 6.0f; } @@ -346,10 +350,9 @@ void WwtDataHandler::saveImageFromNode(tinyxml2::XMLElement* node, _images.push_back(image); } -void WwtDataHandler::saveImagesFromXml(tinyxml2::XMLElement* root, - std::string collection) +void WwtDataHandler::saveImagesFromXml(tinyxml2::XMLElement* root, + std::string collection) { - // Get direct child of node called Place using namespace tinyxml2; XMLElement* node = root->FirstChildElement(); diff --git a/modules/webbrowser/include/screenspacebrowser.h b/modules/webbrowser/include/screenspacebrowser.h index 0803f4de26..417706e9a8 100644 --- a/modules/webbrowser/include/screenspacebrowser.h +++ b/modules/webbrowser/include/screenspacebrowser.h @@ -78,7 +78,6 @@ protected: std::unique_ptr _texture; private: - class ScreenSpaceRenderHandler : public WebRenderHandler { public: void draw() override; @@ -93,16 +92,13 @@ private: void bindTexture() override; properties::StringProperty _url; - properties::TriggerProperty _reload; - CefRefPtr _keyboardHandler; bool _isUrlDirty = false; bool _isDimensionsDirty = false; }; - } // namespace openspace #endif // __OPENSPACE_MODULE_WEBBROWSER___SCREEN_SPACE_BROWSER___H__ diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp index 77a3769c98..0e9b71d653 100644 --- a/src/rendering/renderengine.cpp +++ b/src/rendering/renderengine.cpp @@ -1133,7 +1133,6 @@ void RenderEngine::removeScreenSpaceRenderable(ScreenSpaceRenderable* s) { ); if (it != global::screenSpaceRenderables->end()) { - global::eventEngine->publishEvent(s); s->deinitializeGL(); s->deinitialize(); diff --git a/src/rendering/screenspacerenderable.cpp b/src/rendering/screenspacerenderable.cpp index 9d8c9c8aa1..0e5b476b22 100644 --- a/src/rendering/screenspacerenderable.cpp +++ b/src/rendering/screenspacerenderable.cpp @@ -476,18 +476,19 @@ void ScreenSpaceRenderable::update() {} bool ScreenSpaceRenderable::isEnabled() const { return _enabled; } -bool ScreenSpaceRenderable::isUsingRaeCoords() const -{ + +bool ScreenSpaceRenderable::isUsingRaeCoords() const { return _useRadiusAzimuthElevation; } -bool ScreenSpaceRenderable::isFacingCamera() const -{ + +bool ScreenSpaceRenderable::isFacingCamera() const { return _faceCamera; } -void ScreenSpaceRenderable::setEnabled(bool isEnabled) -{ + +void ScreenSpaceRenderable::setEnabled(bool isEnabled) { _enabled = isEnabled; } + float ScreenSpaceRenderable::depth() { return _useRadiusAzimuthElevation ? _raePosition.value().x : @@ -538,8 +539,9 @@ glm::mat4 ScreenSpaceRenderable::scaleMatrix() { return scale; } -glm::vec2 ScreenSpaceRenderable::screenSpacePosition() { - return glm::vec2(_cartesianPosition.value().x, _cartesianPosition.value().y); + +glm::vec2 ScreenSpaceRenderable::screenSpacePosition() { + return glm::vec2(_cartesianPosition.value()); } glm::vec2 ScreenSpaceRenderable::screenSpaceDimensions() { @@ -555,7 +557,7 @@ glm::vec2 ScreenSpaceRenderable::lowerLeftCornerScreenSpace() { return screenSpacePosition() - (screenSpaceDimensions() / 2.0f); } -bool ScreenSpaceRenderable::intersection(glm::vec2 coord) { +bool ScreenSpaceRenderable::isIntersecting(glm::vec2 coord) { bool isUnderTopBorder = coord.x < upperRightCornerScreenSpace().x; bool isLeftToRightBorder = coord.y < upperRightCornerScreenSpace().y; bool isRightToLeftBorder = coord.x > lowerLeftCornerScreenSpace().x; @@ -574,18 +576,15 @@ void ScreenSpaceRenderable::translate(glm::vec2 translation, glm::vec2 position) _cartesianPosition = translationMatrix * origin; } -void ScreenSpaceRenderable::setCartesianPosition(const glm::vec3& position) -{ +void ScreenSpaceRenderable::setCartesianPosition(const glm::vec3& position) { _cartesianPosition = position; } -void ScreenSpaceRenderable::setRaeFromCartesianPosition(const glm::vec3& position) -{ +void ScreenSpaceRenderable::setRaeFromCartesianPosition(const glm::vec3& position) { _raePosition = cartesianToRae(position); } -glm::vec3 ScreenSpaceRenderable::raePosition() const -{ +glm::vec3 ScreenSpaceRenderable::raePosition() const { return _raePosition; } @@ -623,13 +622,11 @@ glm::mat4 ScreenSpaceRenderable::localRotationMatrix() { return rotation * glm::mat4(glm::quat(glm::vec3(pitch, yaw, roll))); } -glm::vec3 ScreenSpaceRenderable::raeToCartesian(const glm::vec3& rae) const -{ +glm::vec3 ScreenSpaceRenderable::raeToCartesian(const glm::vec3& rae) const { return sphericalToCartesian(raeToSpherical(rae)); } -glm::vec3 ScreenSpaceRenderable::cartesianToRae(const glm::vec3& cartesian) const -{ +glm::vec3 ScreenSpaceRenderable::cartesianToRae(const glm::vec3& cartesian) const { return sphericalToRae(cartesianToSpherical(cartesian)); }