From 7eff6b042e252e23b9db4cbf19fbf81a1793e52e Mon Sep 17 00:00:00 2001 From: Micah Acinapura Date: Tue, 14 Jun 2022 12:09:30 -0400 Subject: [PATCH] added events for when renderables are enabled/disabled that can be used to link renderables together (#2132) --- include/openspace/events/event.h | 29 +++++++++++++++++++ src/events/event.cpp | 48 ++++++++++++++++++++++++++++++++ src/rendering/renderable.cpp | 10 +++++++ 3 files changed, 87 insertions(+) diff --git a/include/openspace/events/event.h b/include/openspace/events/event.h index 4b02129311..c62909c23d 100644 --- a/include/openspace/events/event.h +++ b/include/openspace/events/event.h @@ -35,6 +35,7 @@ namespace openspace { class Camera; class Layer; class Profile; + class Renderable; class SceneGraphNode; class ScreenSpaceRenderable; class Time; @@ -74,6 +75,8 @@ struct Event { LayerRemoved, SessionRecordingPlayback, PointSpacecraft, + RenderableEnabled, + RenderableDisabled, Custom }; constexpr explicit Event(Type type_) : type(type_) {} @@ -397,6 +400,32 @@ struct EventPointSpacecraft : public Event { const double duration; }; +/** + * This event is created whenever a renderable is enabled. By the + * time this event is signalled, the renderable has already been enabled. + * + * \param Node The identifier of the node that contains the renderable + */ +struct EventRenderableEnabled : public Event { + static const Type Type = Event::Type::RenderableEnabled; + + explicit EventRenderableEnabled(const SceneGraphNode* node_); + const tstring node; +}; + +/** + * This event is created whenever a renderable is disabled. By the + * time this event is signalled, the renderable has already been disabled. + * + * \param Node The identifier of that node that contains the renderable + */ +struct EventRenderableDisabled : public Event { + static const Type Type = Event::Type::RenderableDisabled; + + explicit EventRenderableDisabled(const SceneGraphNode* node_); + const tstring node; +}; + /** * A custom event type that can be used in a pinch when no explicit event type is * available. This should only be used in special circumstances and it should be diff --git a/src/events/event.cpp b/src/events/event.cpp index e02857e7e9..16c1d84432 100644 --- a/src/events/event.cpp +++ b/src/events/event.cpp @@ -184,6 +184,17 @@ void log(int i, const CustomEvent& e) { LINFO(fmt::format("[{}] CustomEvent: {} ({})", i, e.subtype, e.payload)); } +void log(int i, const EventRenderableEnabled& e) { + ghoul_assert(e.type == EventRenderableEnabled::Type, "Wrong type"); + LINFO(fmt::format("[{}] EventRenderableEnabled: {}", i, e.node)); +} + +void log(int i, const EventRenderableDisabled& e) { + ghoul_assert(e.type == EventRenderableDisabled::Type, "Wrong type"); + LINFO(fmt::format("[{}] EventRenderableDisabled: {}", i, e.node)); +} + + std::string_view toString(Event::Type type) { switch (type) { case Event::Type::SceneGraphNodeAdded: return "SceneGraphNodeAdded"; @@ -204,6 +215,8 @@ std::string_view toString(Event::Type type) { case Event::Type::LayerRemoved: return "LayerRemoved"; case Event::Type::SessionRecordingPlayback: return "SessionRecordingPlayback"; case Event::Type::PointSpacecraft: return "PointSpacecraft"; + case Event::Type::RenderableEnabled: return "RenderableEnabled"; + case Event::Type::RenderableDisabled: return "RenderableDisabled"; case Event::Type::Custom: return "Custom"; default: throw ghoul::MissingCaseException(); @@ -262,6 +275,12 @@ Event::Type fromString(std::string_view str) { else if (str == "PointSpacecraft") { return Event::Type::PointSpacecraft; } + else if (str == "RenderableEnabled") { + return Event::Type::RenderableEnabled; + } + else if (str == "RenderableDisabled") { + return Event::Type::RenderableDisabled; + } else if (str == "Custom") { return Event::Type::Custom; } @@ -428,6 +447,18 @@ ghoul::Dictionary toParameter(const Event& e) { d.setValue("Dec", static_cast(e).dec); d.setValue("Duration", static_cast(e).duration); break; + case Event::Type::RenderableEnabled: + d.setValue( + "Node", + std::string(static_cast(e).node) + ); + break; + case Event::Type::RenderableDisabled: + d.setValue( + "Node", + std::string(static_cast(e).node) + ); + break; case Event::Type::Custom: d.setValue( "Subtype", std::string(static_cast(e).subtype) @@ -497,6 +528,12 @@ void logAllEvents(const Event* e) { case Event::Type::PointSpacecraft: log(i, *static_cast(e)); break; + case Event::Type::RenderableEnabled: + log(i, *static_cast(e)); + break; + case Event::Type::RenderableDisabled: + log(i, *static_cast(e)); + break; case Event::Type::Custom: log(i, *static_cast(e)); break; @@ -616,6 +653,17 @@ EventPointSpacecraft::EventPointSpacecraft(double ra_, double dec_, double durat , duration(duration_) {} +EventRenderableEnabled::EventRenderableEnabled(const SceneGraphNode* node_) + : Event(Type) + , node(temporaryString(node_->identifier())) +{} + +EventRenderableDisabled::EventRenderableDisabled(const SceneGraphNode* node_) + : Event(Type) + , node(temporaryString(node_->identifier())) +{} + + CustomEvent::CustomEvent(std::string_view subtype_, std::string_view payload_) : Event(Type) , subtype(subtype_) diff --git a/src/rendering/renderable.cpp b/src/rendering/renderable.cpp index 6b8af1b1ec..72577c5a74 100644 --- a/src/rendering/renderable.cpp +++ b/src/rendering/renderable.cpp @@ -27,6 +27,8 @@ #include #include #include +#include +#include #include #include #include @@ -168,6 +170,14 @@ Renderable::Renderable(const ghoul::Dictionary& dictionary) _enabled = p.enabled.value_or(_enabled); addProperty(_enabled); + _enabled.onChange([this]() { + if (isEnabled()) { + global::eventEngine->publishEvent(_parent); + } + else { + global::eventEngine->publishEvent(_parent); + } + }); _opacity = p.opacity.value_or(_opacity); // We don't add the property here as subclasses should decide on their own whether