Add documentation of spacecraftinstrument module types (closes #1847)

modules/spacecraftinstruments/dashboard/dashboarditeminstruments.cpp

@@ -74,6 +74,12 @@ namespace {
         return glm::vec2(std::max(lhs.x, rhs.x), lhs.y + rhs.y);
     }
 
+    // This dashboard item shows information about the status of individual instruments
+    // onboard a spacecraft with regards to upcoming image capture. An image sequence has
+    // to be registered in order to be able to show the necessary information. The
+    // dashboard item shows a visual representation on how much time has passed since the
+    // previous image capture and how much time remains until the instrument captures the
+    // next image.
     struct [[codegen::Dictionary(DashboardItemInstruments)]] Parameters {
         // [[codegen::verbatim(ActiveColorInfo.description)]]
         std::optional<glm::vec3> activeColor [[codegen::color()]];

modules/spacecraftinstruments/rendering/renderablefov.cpp

@@ -142,7 +142,11 @@ namespace {
         }
     }
 
-    // Needs support for std::map first for the frameConversions
+    // This Renderable type shows a visual representation of a spacecraft instrument's
+    // field-of-view. Information about the field-of-view are extracted from SPICE kernels
+    // that must be loaded with the correct information. By default a field-of-view is
+    // only visible while an instrument is active, but the field-of-view can be made
+    // visible at all times through the `AlwaysDrawFov` setting.
     struct [[codegen::Dictionary(RenderableFov)]] Parameters {
         // The SPICE name of the source body for which the field of view should be
         // rendered.

modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp

@@ -47,6 +47,12 @@ namespace {
         openspace::properties::Property::Visibility::NoviceUser
     };
 
+    // Similarly to the [RenderablePlaneProjection](renderableplaneprojection) and
+    // [RenderablePlanetProjection](renderableplanetprojection), this Renderable type
+    // servers as a potential target for image projections from a spacecraft's instrument.
+    // This renderable will determine whenever an image in a currently loaded image
+    // sequence is projected whether that instrument's field of view intersects this model
+    // and will correctly project the captured image onto the model.
     struct [[codegen::Dictionary(RenderableModelProjection)]] Parameters {
         // The file or files that should be loaded, that specifies the model to load. The
         // file can contain filesystem tokens or can be specified relative to the

modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp

@@ -44,6 +44,12 @@
 namespace {
     constexpr std::string_view _loggerCat = "RenderablePlaneProjection";
 
+    // This specialized Renderable type is used as a target for projections from a
+    // spacecraft instrument. Similarly to the
+    // [RenderablePlanetProject](renderableplanetprojection) it uses the spacecraft's
+    // position and orientation and information about an instruments field-of-view and
+    // set of images to project a captured image. In the case of this renderable the
+    // target geometry is a two-dimensional plane that the image is projected on.
     struct [[codegen::Dictionary(RenderablePlaneProjection)]] Parameters {
         // The SPICE name of the spacecraft from which the projection is performed.
         std::string spacecraft;

modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp

@@ -137,6 +137,12 @@ namespace {
         openspace::properties::Property::Visibility::AdvancedUser
     };
 
+    // This Renderable serves as a potential target for images projected from a
+    // spacecraft's instrument. Images have to be loaded into an image sequence first and
+    // when it is then time to project an image into the world from the point of view of
+    // the instrument, the field-of-view will be checked against the extent of this
+    // planetary body. If the field-of-view intersects, the image gets correctly projected
+    // onto the surface.
     struct [[codegen::Dictionary(RenderablePlanetProjection)]] Parameters {
         // Contains information about projecting onto this planet.
         ghoul::Dictionary projection

modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp

@@ -105,6 +105,12 @@ namespace {
         openspace::properties::Property::Visibility::AdvancedUser
     };
 
+    // This Renderable displays the shadow cylinder behind a planetary body. Given the
+    // SPICE name of a planetary body and an observer, it will show a cylinder extending
+    // behind the body away from the observer to highlight the areas of space from which
+    // the observer is occluded by the body. A concrete example is using the Sun as the
+    // observer, in which case the shadow cylinder indicates the areas in which there is
+    // darkness.
     struct [[codegen::Dictionary(RenderableShadowCylinder)]] Parameters {
         // [[codegen::verbatim(NumberPointsInfo.description)]]
         std::optional<int> numberOfPoints;