mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-01 09:10:18 -06:00
338 lines
13 KiB
C++
338 lines
13 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2023 *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
|
|
* software and associated documentation files (the "Software"), to deal in the Software *
|
|
* without restriction, including without limitation the rights to use, copy, modify, *
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
|
|
* permit persons to whom the Software is furnished to do so, subject to the following *
|
|
* conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in all copies *
|
|
* or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
|
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
****************************************************************************************/
|
|
|
|
#include <modules/base/dashboard/dashboarditemangle.h>
|
|
|
|
#include <openspace/camera/camera.h>
|
|
#include <openspace/documentation/documentation.h>
|
|
#include <openspace/documentation/verifier.h>
|
|
#include <openspace/engine/globals.h>
|
|
#include <openspace/navigation/navigationhandler.h>
|
|
#include <openspace/navigation/orbitalnavigator.h>
|
|
#include <openspace/rendering/renderengine.h>
|
|
#include <openspace/scene/scene.h>
|
|
#include <openspace/scene/scenegraphnode.h>
|
|
#include <ghoul/font/font.h>
|
|
#include <ghoul/font/fontmanager.h>
|
|
#include <ghoul/font/fontrenderer.h>
|
|
#include <ghoul/logging/logmanager.h>
|
|
#include <ghoul/misc/profiling.h>
|
|
|
|
namespace {
|
|
enum Type {
|
|
Node = 0,
|
|
Focus,
|
|
Camera
|
|
};
|
|
|
|
constexpr openspace::properties::Property::PropertyInfo SourceTypeInfo = {
|
|
"SourceType",
|
|
"Source Type",
|
|
"The type of position that is used as the triangle apex used to calculate the "
|
|
"angle. The default value is 'Camera'",
|
|
// @VISIBILITY(2.67)
|
|
openspace::properties::Property::Visibility::User
|
|
};
|
|
|
|
constexpr openspace::properties::Property::PropertyInfo SourceNodeNameInfo = {
|
|
"SourceNodeName",
|
|
"Source Node Name",
|
|
"If a scene graph node is selected as type, this value specifies the name of the "
|
|
"node that is to be used as the apex of the triangle used to calculate the "
|
|
"angle. The computed angle is the incident angle to Source in the triangle ("
|
|
"Source, Reference, Destination)",
|
|
// @VISIBILITY(2.67)
|
|
openspace::properties::Property::Visibility::User
|
|
};
|
|
|
|
constexpr openspace::properties::Property::PropertyInfo ReferenceTypeInfo = {
|
|
"ReferenceType",
|
|
"Reference Type",
|
|
"The type of position that is used as the destination of the reference line used "
|
|
"to calculate the angle. The computed angle is the incident angle to Source in "
|
|
"the triangle (Source, Reference, Destination)",
|
|
// @VISIBILITY(2.67)
|
|
openspace::properties::Property::Visibility::User
|
|
};
|
|
|
|
constexpr openspace::properties::Property::PropertyInfo ReferenceNodeNameInfo = {
|
|
"ReferenceNodeName",
|
|
"Reference Node Name",
|
|
"If a scene graph node is selected as type, this value specifies the name of the "
|
|
"node that is to be used as the reference direction to compute the angle",
|
|
// @VISIBILITY(2.67)
|
|
openspace::properties::Property::Visibility::User
|
|
};
|
|
|
|
constexpr openspace::properties::Property::PropertyInfo DestinationTypeInfo = {
|
|
"DestinationType",
|
|
"Destination Type",
|
|
"The type of position that is used as the destination to calculate the angle. "
|
|
"The computed angle is the incident angle to Source in the triangle ("
|
|
"Source, Reference, Destination). The default value for this is 'Focus'",
|
|
// @VISIBILITY(2.67)
|
|
openspace::properties::Property::Visibility::User
|
|
};
|
|
|
|
constexpr openspace::properties::Property::PropertyInfo DestinationNodeNameInfo = {
|
|
"DestinationNodeName",
|
|
"Destination Node Name",
|
|
"If a scene graph node is selected as type, this value specifies the name of the "
|
|
"node that is to be used as the destination for computing the angle",
|
|
// @VISIBILITY(2.67)
|
|
openspace::properties::Property::Visibility::User
|
|
};
|
|
|
|
struct [[codegen::Dictionary(DashboardItemAngle)]] Parameters {
|
|
enum class [[codegen::map(Type)]] Type {
|
|
Node,
|
|
Focus,
|
|
Camera
|
|
};
|
|
|
|
// [[codegen::verbatim(SourceTypeInfo.description)]]
|
|
std::optional<Type> sourceType;
|
|
// [[codegen::verbatim(SourceNodeNameInfo.description)]]
|
|
std::optional<std::string> sourceNodeName;
|
|
// [[codegen::verbatim(ReferenceTypeInfo.description)]]
|
|
Type referenceType;
|
|
// [[codegen::verbatim(ReferenceNodeNameInfo.description)]]
|
|
std::optional<std::string> referenceNodeName;
|
|
// [[codegen::verbatim(DestinationTypeInfo.description)]]
|
|
std::optional<Type> destinationType;
|
|
// [[codegen::verbatim(DestinationNodeNameInfo.description)]]
|
|
std::optional<std::string> destinationNodeName;
|
|
};
|
|
#include "dashboarditemangle_codegen.cpp"
|
|
} // namespace
|
|
|
|
namespace openspace {
|
|
|
|
documentation::Documentation DashboardItemAngle::Documentation() {
|
|
documentation::Documentation doc =
|
|
codegen::doc<Parameters>("base_dashboarditem_angle");
|
|
|
|
// @TODO cleanup
|
|
// Insert the parent's documentation entries until we have a verifier that can deal
|
|
// with class hierarchy
|
|
documentation::Documentation parentDoc = DashboardTextItem::Documentation();
|
|
doc.entries.insert(
|
|
doc.entries.end(),
|
|
parentDoc.entries.begin(),
|
|
parentDoc.entries.end()
|
|
);
|
|
|
|
return doc;
|
|
}
|
|
|
|
DashboardItemAngle::DashboardItemAngle(const ghoul::Dictionary& dictionary)
|
|
: DashboardTextItem(dictionary)
|
|
, _source{
|
|
properties::OptionProperty(
|
|
SourceTypeInfo,
|
|
properties::OptionProperty::DisplayType::Dropdown
|
|
),
|
|
properties::StringProperty(SourceNodeNameInfo),
|
|
nullptr
|
|
}
|
|
, _reference{
|
|
properties::OptionProperty(
|
|
ReferenceTypeInfo,
|
|
properties::OptionProperty::DisplayType::Dropdown
|
|
),
|
|
properties::StringProperty(ReferenceNodeNameInfo),
|
|
nullptr
|
|
}
|
|
, _destination{
|
|
properties::OptionProperty(
|
|
DestinationTypeInfo,
|
|
properties::OptionProperty::DisplayType::Dropdown
|
|
),
|
|
properties::StringProperty(DestinationNodeNameInfo),
|
|
nullptr
|
|
}
|
|
{
|
|
const Parameters p = codegen::bake<Parameters>(dictionary);
|
|
|
|
_source.type.addOptions({
|
|
{ Type::Node, "Node" },
|
|
{ Type::Focus, "Focus" },
|
|
{ Type::Camera, "Camera" }
|
|
});
|
|
if (p.sourceType.has_value()) {
|
|
_source.type = codegen::map<Type>(*p.sourceType);
|
|
}
|
|
else {
|
|
_source.type = Type::Camera;
|
|
}
|
|
addProperty(_source.type);
|
|
|
|
_source.nodeName.onChange([this]() { _source.node = nullptr; });
|
|
if (_source.type == Type::Node) {
|
|
if (p.sourceNodeName.has_value()) {
|
|
_source.nodeName = *p.sourceNodeName;
|
|
}
|
|
else {
|
|
LERRORC(
|
|
"DashboardItemAngle",
|
|
"Node type was selected for source but no node specified"
|
|
);
|
|
}
|
|
}
|
|
addProperty(_source.nodeName);
|
|
|
|
|
|
_reference.type.addOptions({
|
|
{ Type::Node, "Node" },
|
|
{ Type::Focus, "Focus" },
|
|
{ Type::Camera, "Camera" }
|
|
});
|
|
_reference.type = codegen::map<Type>(p.referenceType);
|
|
addProperty(_reference.type);
|
|
|
|
_reference.nodeName.onChange([this]() { _reference.node = nullptr; });
|
|
if (_reference.type == Type::Node) {
|
|
if (p.referenceNodeName.has_value()) {
|
|
_reference.nodeName = *p.referenceNodeName;
|
|
}
|
|
else {
|
|
LERRORC(
|
|
"DashboardItemAngle",
|
|
"Node type was selected for reference but no node specified"
|
|
);
|
|
}
|
|
}
|
|
addProperty(_reference.nodeName);
|
|
|
|
_destination.type.addOptions({
|
|
{ Type::Node, "Node" },
|
|
{ Type::Focus, "Focus" },
|
|
{ Type::Camera, "Camera" }
|
|
});
|
|
if (p.destinationType.has_value()) {
|
|
_destination.type = codegen::map<Type>(*p.destinationType);
|
|
}
|
|
else {
|
|
_destination.type = Type::Focus;
|
|
}
|
|
addProperty(_destination.type);
|
|
_destination.nodeName.onChange([this]() { _destination.node = nullptr; });
|
|
if (_destination.type == Type::Node) {
|
|
if (p.destinationNodeName.has_value()) {
|
|
_destination.nodeName = *p.destinationNodeName;
|
|
}
|
|
else {
|
|
LERRORC(
|
|
"DashboardItemAngle",
|
|
"Node type was selected for destination but no node specified"
|
|
);
|
|
}
|
|
}
|
|
addProperty(_destination.nodeName);
|
|
|
|
_buffer.resize(128);
|
|
}
|
|
|
|
std::pair<glm::dvec3, std::string> DashboardItemAngle::positionAndLabel(
|
|
Component& comp) const
|
|
{
|
|
if (comp.type == Type::Node) {
|
|
if (!comp.node) {
|
|
comp.node = global::renderEngine->scene()->sceneGraphNode(comp.nodeName);
|
|
|
|
if (!comp.node) {
|
|
LERRORC(
|
|
"DashboardItemAngle",
|
|
"Could not find node '" + comp.nodeName.value() + "'"
|
|
);
|
|
return { glm::dvec3(0.0), "Node" };
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (comp.type) {
|
|
case Type::Node:
|
|
return { comp.node->worldPosition(), comp.node->guiName() };
|
|
case Type::Focus:
|
|
{
|
|
const SceneGraphNode* node =
|
|
global::navigationHandler->orbitalNavigator().anchorNode();
|
|
return {
|
|
node->worldPosition(),
|
|
"focus"
|
|
};
|
|
}
|
|
case Type::Camera:
|
|
return { global::renderEngine->scene()->camera()->positionVec3(), "camera" };
|
|
default:
|
|
return { glm::dvec3(0.0), "Unknown" };
|
|
}
|
|
}
|
|
|
|
void DashboardItemAngle::render(glm::vec2& penPosition) {
|
|
ZoneScoped;
|
|
|
|
std::pair<glm::dvec3, std::string> sourceInfo = positionAndLabel(_source);
|
|
std::pair<glm::dvec3, std::string> referenceInfo = positionAndLabel(_reference);
|
|
std::pair<glm::dvec3, std::string> destinationInfo = positionAndLabel(_destination);
|
|
|
|
const glm::dvec3 a = referenceInfo.first - sourceInfo.first;
|
|
const glm::dvec3 b = destinationInfo.first - sourceInfo.first;
|
|
|
|
std::fill(_buffer.begin(), _buffer.end(), char(0));
|
|
if (glm::length(a) == 0.0 || glm::length(b) == 0) {
|
|
char* end = fmt::format_to(
|
|
_buffer.data(),
|
|
"Could not compute angle at {} between {} and {}",
|
|
sourceInfo.second, destinationInfo.second, referenceInfo.second
|
|
);
|
|
std::string_view text = std::string_view(_buffer.data(), end - _buffer.data());
|
|
RenderFont(*_font, penPosition, text);
|
|
penPosition.y -= _font->height();
|
|
}
|
|
else {
|
|
const double angle = glm::degrees(
|
|
glm::acos(glm::dot(a, b) / (glm::length(a) * glm::length(b)))
|
|
);
|
|
|
|
char* end = fmt::format_to(
|
|
_buffer.data(),
|
|
"Angle at {} between {} and {}: {} degrees",
|
|
sourceInfo.second, destinationInfo.second, referenceInfo.second, angle
|
|
);
|
|
std::string_view text = std::string_view(_buffer.data(), end - _buffer.data());
|
|
RenderFont(*_font, penPosition, text);
|
|
penPosition.y -= _font->height();
|
|
}
|
|
}
|
|
|
|
glm::vec2 DashboardItemAngle::size() const {
|
|
ZoneScoped;
|
|
|
|
constexpr double Angle = 120;
|
|
return _font->boundingBox("Angle: " + std::to_string(Angle));
|
|
}
|
|
|
|
} // namespace openspace
|