Add a hidden "Fade" property that modifies the effective opacity to enable other functionality (closes #1970)

2026-02-22 12:59:07 -06:00 · 2022-04-05 23:53:33 +02:00
parent 73292ee54c
commit 02adcf570e
32 changed files with 79 additions and 36 deletions
--- a/include/openspace/rendering/renderable.h
+++ b/include/openspace/rendering/renderable.h
@@ -105,6 +105,7 @@ public:
 protected:
    properties::BoolProperty _enabled;
    properties::FloatProperty _opacity;
+    properties::FloatProperty _fade;
    properties::StringProperty _renderableType;

    void setBoundingSphere(double boundingSphere);
@@ -113,6 +114,9 @@ protected:
    void setRenderBinFromOpacity();
    void registerUpdateRenderBinFromOpacity();

+    /// Returns the full opacity constructed from the _opactiy and _fade property values
+    float opacity() const;
+
    double _boundingSphere = 0.0;
    double _interactionSphere = 0.0;
    SceneGraphNode* _parent = nullptr;
--- a/include/openspace/rendering/screenspacerenderable.h
+++ b/include/openspace/rendering/screenspacerenderable.h
@@ -88,6 +88,8 @@ protected:
    virtual void bindTexture() = 0;
    virtual void unbindTexture();

+    float opacity() const;
+
    properties::BoolProperty _enabled;
    properties::BoolProperty _usePerspectiveProjection;
    properties::BoolProperty _useRadiusAzimuthElevation;
@@ -108,6 +110,7 @@ protected:
    properties::Vec3Property _multiplyColor;
    properties::Vec4Property _backgroundColor;
    properties::FloatProperty _opacity;
+    properties::FloatProperty _fade;
    properties::TriggerProperty _delete;

    glm::ivec2 _objectSize = glm::ivec2(0);
--- a/modules/base/rendering/grids/renderableboxgrid.cpp
+++ b/modules/base/rendering/grids/renderableboxgrid.cpp
@@ -154,7 +154,7 @@ void RenderableBoxGrid::render(const RenderData& data, RendererTasks&){
        "MVPTransform",
        glm::dmat4(data.camera.projectionMatrix()) * modelViewTransform
    );
-    _gridProgram->setUniform("opacity", _opacity);
+    _gridProgram->setUniform("opacity", opacity());
    _gridProgram->setUniform("gridColor", _color);

    // Change GL state:
--- a/modules/base/rendering/grids/renderablegrid.cpp
+++ b/modules/base/rendering/grids/renderablegrid.cpp
@@ -170,7 +170,7 @@ void RenderableGrid::render(const RenderData& data, RendererTasks&){
        "MVPTransform",
        glm::dmat4(data.camera.projectionMatrix()) * modelViewTransform
    );
-    _gridProgram->setUniform("opacity", _opacity);
+    _gridProgram->setUniform("opacity", opacity());
    _gridProgram->setUniform("gridColor", _color);

    // Change GL state:
--- a/modules/base/rendering/grids/renderableradialgrid.cpp
+++ b/modules/base/rendering/grids/renderableradialgrid.cpp
@@ -181,7 +181,7 @@ void RenderableRadialGrid::render(const RenderData& data, RendererTasks&) {
        "MVPTransform",
        glm::dmat4(data.camera.projectionMatrix()) * modelViewTransform
    );
-    _gridProgram->setUniform("opacity", _opacity);
+    _gridProgram->setUniform("opacity", opacity());
    _gridProgram->setUniform("gridColor", _color);

    // Change GL state:
--- a/modules/base/rendering/grids/renderablesphericalgrid.cpp
+++ b/modules/base/rendering/grids/renderablesphericalgrid.cpp
@@ -172,7 +172,7 @@ void RenderableSphericalGrid::render(const RenderData& data, RendererTasks&){
        "MVPTransform",
        glm::dmat4(data.camera.projectionMatrix()) * modelViewTransform
    );
-    _gridProgram->setUniform("opacity", _opacity);
+    _gridProgram->setUniform("opacity", opacity());
    _gridProgram->setUniform("gridColor", _color);

    // Change GL state:
--- a/modules/base/rendering/renderabledisc.cpp
+++ b/modules/base/rendering/renderabledisc.cpp
@@ -155,7 +155,7 @@ void RenderableDisc::render(const RenderData& data, RendererTasks&) {
        data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
    );
    _shader->setUniform(_uniformCache.width, _width);
-    _shader->setUniform(_uniformCache.opacity, _opacity);
+    _shader->setUniform(_uniformCache.opacity, opacity());

    ghoul::opengl::TextureUnit unit;
    unit.activate();
--- a/modules/base/rendering/renderablelabels.cpp
+++ b/modules/base/rendering/renderablelabels.cpp
@@ -439,7 +439,7 @@ void RenderableLabels::renderLabels(const RenderData& data,
    glm::vec4 textColor = glm::vec4(glm::vec3(_color), 1.f);

    textColor.a *= fadeInVariable;
-    textColor.a *= _opacity;
+    textColor.a *= opacity();

    ghoul::fontrendering::FontRenderer::ProjectedLabelsInformation labelInfo;

--- a/modules/base/rendering/renderablemodel.cpp
+++ b/modules/base/rendering/renderablemodel.cpp
@@ -579,7 +579,7 @@ void RenderableModel::render(const RenderData& data, RendererTasks&) {
    if (distanceToCamera < maxDistance) {
        _program->activate();

-        _program->setUniform(_uniformCache.opacity, _opacity);
+        _program->setUniform(_uniformCache.opacity, opacity());

        // Model transform and view transform needs to be in double precision
        const glm::dmat4 modelTransform =
--- a/modules/base/rendering/renderablenodeline.cpp
+++ b/modules/base/rendering/renderablenodeline.cpp
@@ -270,7 +270,7 @@ void RenderableNodeLine::render(const RenderData& data, RendererTasks&) {

    _program->setUniform("modelViewTransform", glm::mat4(modelViewTransform));
    _program->setUniform("projectionTransform", data.camera.projectionMatrix());
-    _program->setUniform("color", glm::vec4(_lineColor.value(), _opacity));
+    _program->setUniform("color", glm::vec4(_lineColor.value(), opacity()));

    // Change GL state:
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
--- a/modules/base/rendering/renderableplane.cpp
+++ b/modules/base/rendering/renderableplane.cpp
@@ -217,7 +217,7 @@ void RenderablePlane::render(const RenderData& data, RendererTasks&) {
    ZoneScoped

    _shader->activate();
-    _shader->setUniform("opacity", _opacity);
+    _shader->setUniform("opacity", opacity());

    _shader->setUniform("mirrorBackside", _mirrorBackside);

--- a/modules/base/rendering/renderableprism.cpp
+++ b/modules/base/rendering/renderableprism.cpp
@@ -318,7 +318,7 @@ void RenderablePrism::render(const RenderData& data, RendererTasks&) {

    // Uniforms
    _shader->setUniform(_uniformCache.modelViewProjection, modelViewProjectionTransform);
-    _shader->setUniform(_uniformCache.color, glm::vec4(_lineColor.value(), _opacity));
+    _shader->setUniform(_uniformCache.color, glm::vec4(_lineColor.value(), opacity()));

    // Render
    glEnable(GL_PRIMITIVE_RESTART);
--- a/modules/base/rendering/renderablesphere.cpp
+++ b/modules/base/rendering/renderablesphere.cpp
@@ -280,7 +280,7 @@ void RenderableSphere::render(const RenderData& data, RendererTasks&) {
    );
    _shader->setUniform(_uniformCache.modelViewRotation, modelViewRotation);

-    float adjustedOpacity = _opacity;
+    float adjustedOpacity = opacity();

    if (!_disableFadeInDistance) {
        if (_fadeInThreshold > -1.0) {
--- a/modules/base/rendering/renderabletimevaryingsphere.cpp
+++ b/modules/base/rendering/renderabletimevaryingsphere.cpp
@@ -275,7 +275,7 @@ void RenderableTimeVaryingSphere::render(const RenderData& data, RendererTasks&)
    );
    _shader->setUniform(_uniformCache.modelViewRotation, modelViewRotation);

-    float adjustedOpacity = _opacity;
+    float adjustedOpacity = opacity();

    if (!_disableFadeInDistance) {
        if (_fadeInThreshold > -1.0) {
--- a/modules/base/rendering/renderabletrail.cpp
+++ b/modules/base/rendering/renderabletrail.cpp
@@ -384,7 +384,7 @@ void RenderableTrail::render(const RenderData& data, RendererTasks&) {
    ZoneScoped

    _programObject->activate();
-    _programObject->setUniform(_uniformCache.opacity, _opacity);
+    _programObject->setUniform(_uniformCache.opacity, opacity());

    glm::dmat4 modelTransform =
        glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
--- a/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
+++ b/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
@@ -683,7 +683,7 @@ void RenderableBillboardsCloud::renderBillboards(const RenderData& data,
    _program->setUniform(_uniformCache.minBillboardSize, minBillboardSize);
    _program->setUniform(_uniformCache.maxBillboardSize, maxBillboardSize);
    _program->setUniform(_uniformCache.color, _pointColor);
-    _program->setUniform(_uniformCache.alphaValue, _opacity);
+    _program->setUniform(_uniformCache.alphaValue, opacity());
    _program->setUniform(_uniformCache.scaleFactor, _scaleFactor);
    _program->setUniform(_uniformCache.up, glm::vec3(orthoUp));
    _program->setUniform(_uniformCache.right, glm::vec3(orthoRight));
--- a/modules/digitaluniverse/rendering/renderabledumeshes.cpp
+++ b/modules/digitaluniverse/rendering/renderabledumeshes.cpp
@@ -320,7 +320,7 @@ void RenderableDUMeshes::renderMeshes(const RenderData&,

    _program->setUniform(_uniformCache.modelViewTransform, modelViewMatrix);
    _program->setUniform(_uniformCache.projectionTransform, projectionMatrix);
-    _program->setUniform(_uniformCache.alphaValue, _opacity);
+    _program->setUniform(_uniformCache.alphaValue, opacity());

    for (const std::pair<const int, RenderingMesh>& pair : _renderingMeshesMap) {
        _program->setUniform(_uniformCache.color, _meshColorMap[pair.second.colorIndex]);
--- a/modules/digitaluniverse/rendering/renderableplanescloud.cpp
+++ b/modules/digitaluniverse/rendering/renderableplanescloud.cpp
@@ -455,7 +455,7 @@ void RenderablePlanesCloud::renderPlanes(const RenderData&,
        _uniformCache.modelViewProjectionTransform,
        modelViewProjectionMatrix
    );
-    _program->setUniform(_uniformCache.alphaValue, _opacity);
+    _program->setUniform(_uniformCache.alphaValue, opacity());
    _program->setUniform(_uniformCache.fadeInValue, fadeInVariable);

    glDisable(GL_CULL_FACE);
--- a/modules/digitaluniverse/rendering/renderablepoints.cpp
+++ b/modules/digitaluniverse/rendering/renderablepoints.cpp
@@ -242,7 +242,7 @@ void RenderablePoints::render(const RenderData& data, RendererTasks&) {

    _program->setUniform(_uniformCache.color, _pointColor);
    _program->setUniform(_uniformCache.sides, 4);
-    _program->setUniform(_uniformCache.alphaValue, _opacity);
+    _program->setUniform(_uniformCache.alphaValue, opacity());
    _program->setUniform(_uniformCache.scaleFactor, _scaleFactor);

    if (_hasSpriteTexture) {
--- a/modules/exoplanets/rendering/renderableorbitdisc.cpp
+++ b/modules/exoplanets/rendering/renderableorbitdisc.cpp
@@ -176,7 +176,7 @@ void RenderableOrbitDisc::render(const RenderData& data, RendererTasks&) {
        data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
    );
    _shader->setUniform(_uniformCache.offset, _offset);
-    _shader->setUniform(_uniformCache.opacity, _opacity);
+    _shader->setUniform(_uniformCache.opacity, opacity());
    _shader->setUniform(_uniformCache.eccentricity, _eccentricity);
    _shader->setUniform(_uniformCache.semiMajorAxis, _size);

--- a/modules/globebrowsing/src/renderableglobe.cpp
+++ b/modules/globebrowsing/src/renderableglobe.cpp
@@ -967,8 +967,8 @@ void RenderableGlobe::renderChunks(const RenderData& data, RendererTasks&,
        _globalRenderer.program->setUniform("orenNayarRoughness", onr);
    }

-    _localRenderer.program->setUniform("opacity", _opacity);
-    _globalRenderer.program->setUniform("opacity", _opacity);
+    _localRenderer.program->setUniform("opacity", opacity());
+    _globalRenderer.program->setUniform("opacity", opacity());


    if (_globalRenderer.updatedSinceLastCall) {
--- a/modules/space/rendering/renderablehabitablezone.cpp
+++ b/modules/space/rendering/renderablehabitablezone.cpp
@@ -150,7 +150,7 @@ void RenderableHabitableZone::render(const RenderData& data, RendererTasks&) {
        data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
    );
    _shader->setUniform(_uniformCache.width, _width);
-    _shader->setUniform(_uniformCache.opacity, _opacity);
+    _shader->setUniform(_uniformCache.opacity, opacity());
    _shader->setUniform(_uniformCache.conservativeBounds, _conservativeBounds);
    _shader->setUniform(_uniformCache.showOptimistic, _showOptimistic);

--- a/modules/space/rendering/renderableorbitalkepler.cpp
+++ b/modules/space/rendering/renderableorbitalkepler.cpp
@@ -451,7 +451,7 @@ void RenderableOrbitalKepler::render(const RenderData& data, RendererTasks&) {
    }

    _programObject->activate();
-    _programObject->setUniform(_uniformCache.opacity, _opacity);
+    _programObject->setUniform(_uniformCache.opacity, opacity());
    _programObject->setUniform(_uniformCache.inGameTime, data.time.j2000Seconds());

    glm::dmat4 modelTransform =
--- a/modules/space/rendering/renderablestars.cpp
+++ b/modules/space/rendering/renderablestars.cpp
@@ -1034,10 +1034,10 @@ void RenderableStars::render(const RenderData& data, RendererTasks&) {
        const double funcValue = a * distCamera + b;
        fadeInVariable *= static_cast<float>(funcValue > 1.f ? 1.f : funcValue);

-        _program->setUniform(_uniformCache.alphaValue, _opacity * fadeInVariable);
+        _program->setUniform(_uniformCache.alphaValue, opacity() * fadeInVariable);
    }
    else {
-        _program->setUniform(_uniformCache.alphaValue, _opacity);
+        _program->setUniform(_uniformCache.alphaValue, opacity());
    }

    ghoul::opengl::TextureUnit psfUnit;
--- a/modules/space/rendering/renderabletravelspeed.cpp
+++ b/modules/space/rendering/renderabletravelspeed.cpp
@@ -290,7 +290,7 @@ void RenderableTravelSpeed::update(const UpdateData& data) {
    }

    _shaderProgram->setUniform("lineColor", _lineColor);
-    _shaderProgram->setUniform("opacity", _opacity);
+    _shaderProgram->setUniform("opacity", opacity());
 }

 void RenderableTravelSpeed::render(const RenderData& data, RendererTasks& ) {
--- a/modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp
+++ b/modules/spacecraftinstruments/rendering/renderableshadowcylinder.cpp
@@ -265,7 +265,7 @@ void RenderableShadowCylinder::render(const RenderData& data, RendererTasks&) {
    );

    _shader->setUniform(_uniformCache.shadowColor, _shadowColor);
-    _shader->setUniform(_uniformCache.opacity, _opacity);
+    _shader->setUniform(_uniformCache.opacity, opacity());

    glBindVertexArray(_vao);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, static_cast<GLsizei>(_vertices.size()));
--- a/modules/toyvolume/rendering/renderabletoyvolume.cpp
+++ b/modules/toyvolume/rendering/renderabletoyvolume.cpp
@@ -140,7 +140,7 @@ RenderableToyVolume::RenderableToyVolume(const ghoul::Dictionary& dictionary)
 RenderableToyVolume::~RenderableToyVolume() {}

 void RenderableToyVolume::initializeGL() {
-    glm::vec4 color(glm::vec3(_color), _opacity);
+    glm::vec4 color(glm::vec3(_color), opacity());
    _raycaster = std::make_unique<ToyVolumeRaycaster>(color);
    _raycaster->initialize();

@@ -197,7 +197,7 @@ void RenderableToyVolume::update(const UpdateData& data) {
                std::pow(10.f, static_cast<float>(_scalingExponent))
        );

-        glm::vec4 color(glm::vec3(_color), _opacity);
+        glm::vec4 color(glm::vec3(_color), opacity());

        _raycaster->setColor(color);
        _raycaster->setStepSize(_stepSize);
--- a/modules/volume/rendering/basicvolumeraycaster.cpp
+++ b/modules/volume/rendering/basicvolumeraycaster.cpp
@@ -137,7 +137,7 @@ void BasicVolumeRaycaster::preRaycast(const RaycastData& data,
    program.setUniform("nClips_" + id, nClips);
    program.setUniform("clipNormals_" + id, clipNormals);
    program.setUniform("clipOffsets_" + id, clipOffsets);
-    program.setUniform("opacity_" + id, _opacity);
+    program.setUniform("opacity_" + id, opacity());
    program.setUniform("rNormalization_" + id, _rNormalization);
    program.setUniform("rUpperBound_" + id, _rUpperBound);
 }
--- a/modules/volume/rendering/renderabletimevaryingvolume.cpp
+++ b/modules/volume/rendering/renderabletimevaryingvolume.cpp
@@ -452,7 +452,7 @@ void RenderableTimeVaryingVolume::update(const UpdateData&) {
            _raycaster->setVolumeTexture(nullptr);
        }
        _raycaster->setStepSize(_stepSize);
-        _raycaster->setOpacity(_opacity);
+        _raycaster->setOpacity(opacity());
        _raycaster->setRNormalization(_rNormalization);
        _raycaster->setRUpperBound(_rUpperBound);
    }
--- a/src/rendering/renderable.cpp
+++ b/src/rendering/renderable.cpp
@@ -51,6 +51,18 @@ namespace {
        "completely transparent."
    };

+    constexpr openspace::properties::Property::PropertyInfo FadeInfo = {
+        "Fade",
+        "Fade",
+        "This value is used by the system to be able to fade out renderables "
+        "independently from the Opacity value selected by the user. This value should "
+        "not be directly manipulated through a user interface, but instead used by other "
+        "components of the system programmatically",
+        // The Developer mode should be used once the properties in the UI listen to this
+        // openspace::properties::Property::Visibility::Developer
+        openspace::properties::Property::Visibility::Hidden
+    };
+
    constexpr openspace::properties::Property::PropertyInfo RenderableTypeInfo = {
        "Type",
        "Renderable Type",
@@ -58,7 +70,8 @@ namespace {
        openspace::properties::Property::Visibility::Hidden
    };

-    constexpr openspace::properties::Property::PropertyInfo RenderableRenderBinModeInfo = {
+    constexpr openspace::properties::Property::PropertyInfo RenderableRenderBinModeInfo =
+    {
        "RenderBinMode",
        "Render Bin Mode",
        "This value specifies if the renderable should be rendered in the Background,"
@@ -128,6 +141,7 @@ Renderable::Renderable(const ghoul::Dictionary& dictionary)
    : properties::PropertyOwner({ "Renderable" })
    , _enabled(EnabledInfo, true)
    , _opacity(OpacityInfo, 1.f, 0.f, 1.f)
+    , _fade(FadeInfo, 1.f, 0.f, 1.f)
    , _renderableType(RenderableTypeInfo, "Renderable")
 {
    ZoneScoped
@@ -158,6 +172,8 @@ Renderable::Renderable(const ghoul::Dictionary& dictionary)
    // We don't add the property here as subclasses should decide on their own whether
    // they to expose the opacity or not

+    addProperty(_fade);
+
    // set type for UI
    _renderableType = p.type.value_or(_renderableType);
    addProperty(_renderableType);
@@ -224,7 +240,7 @@ bool Renderable::matchesRenderBinMask(int binMask) {
 }

 bool Renderable::isVisible() const {
-    return _enabled;
+    return _enabled && _opacity > 0.f && _fade > 0.f;
 }

 bool Renderable::isReady() const {
@@ -249,7 +265,8 @@ void Renderable::setRenderBinFromOpacity() {
    if ((_renderBin != Renderable::RenderBin::PostDeferredTransparent) &&
        (_renderBin != Renderable::RenderBin::Overlay))
    {
-        if (_opacity >= 0.f && _opacity < 1.f) {
+        const float v = opacity();
+        if (v >= 0.f && v < 1.f) {
            setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
        }
        else {
@@ -262,4 +279,8 @@ void Renderable::registerUpdateRenderBinFromOpacity() {
    _opacity.onChange([this]() { setRenderBinFromOpacity(); });
 }

+float Renderable::opacity() const {
+    return _opacity * _fade;
+}
+
 }  // namespace openspace
--- a/src/rendering/screenspacerenderable.cpp
+++ b/src/rendering/screenspacerenderable.cpp
@@ -124,6 +124,16 @@ namespace {
        "completely transparent."
    };

+    constexpr openspace::properties::Property::PropertyInfo FadeInfo = {
+        "Fade",
+        "Fade",
+        "This value is used by the system to be able to fade out renderables "
+        "independently from the Opacity value selected by the user. This value should "
+        "not be directly manipulated through a user interface, but instead used by other "
+        "components of the system programmatically",
+        openspace::properties::Property::Visibility::Developer
+    };
+
    constexpr openspace::properties::Property::PropertyInfo DeleteInfo = {
        "Delete",
        "Delete",
@@ -350,6 +360,7 @@ ScreenSpaceRenderable::ScreenSpaceRenderable(const ghoul::Dictionary& dictionary
        glm::vec4(1.f)
    )
    , _opacity(OpacityInfo, 1.f, 0.f, 1.f)
+    , _fade(FadeInfo, 1.f, 0.f, 1.f)
    , _delete(DeleteInfo)
 {
    const Parameters p = codegen::bake<Parameters>(dictionary);
@@ -383,6 +394,7 @@ ScreenSpaceRenderable::ScreenSpaceRenderable(const ghoul::Dictionary& dictionary
    addProperty(_multiplyColor);
    addProperty(_backgroundColor);
    addProperty(_opacity);
+    addProperty(_fade);
    addProperty(_localRotation);


@@ -589,7 +601,7 @@ void ScreenSpaceRenderable::draw(glm::mat4 modelTransform) {
    _shader->activate();

    _shader->setUniform(_uniformCache.color, _multiplyColor);
-    _shader->setUniform(_uniformCache.opacity, _opacity);
+    _shader->setUniform(_uniformCache.opacity, opacity());
    _shader->setUniform(_uniformCache.backgroundColor, _backgroundColor);

    _shader->setUniform(
@@ -613,4 +625,8 @@ void ScreenSpaceRenderable::draw(glm::mat4 modelTransform) {

 void ScreenSpaceRenderable::unbindTexture() {}

+float ScreenSpaceRenderable::opacity() const {
+    return _opacity * _fade;
+}
+
 } // namespace openspace
--- a/src/scene/scenegraphnode.cpp
+++ b/src/scene/scenegraphnode.cpp
@@ -715,8 +715,7 @@ void SceneGraphNode::render(const RenderData& data, RendererTasks& tasks) {
    }

    const bool visible = _renderable && _renderable->isVisible() &&
-        _renderable->isReady() && _renderable->isEnabled() &&
-        _renderable->matchesRenderBinMask(data.renderBinMask);
+        _renderable->isReady() && _renderable->matchesRenderBinMask(data.renderBinMask);

    if (!visible) {
        return;