Files
pixelarium/lib/app/rendering/RenderImageManager.cpp
m-aXimilian c00c2c71ac
MegaLinter / MegaLinter (push) Has been cancelled
CI Workflow / build-ubuntu (push) Has been cancelled
CI Workflow / build-windows (push) Has been cancelled
CI Workflow / generate-docs (push) Has been cancelled
build system and module refactoring + simple histogram scratch (#20)
* scratch adding histogram to image views

Histograms should come from some sort of histogram service. This is
currently just a POC.

* custom logger implementation w/o spdlog

* missing cmake file

* fix tests

* use operator<< over direct stream exposure

* rm print header

* add threading test + refactor towards interface libraries

omits the need for =target_include_directories= calls /everywhere/

* rm print header

* rm constexpr

* templated thread_pool

* fix doxyfile

* default enable doc building

* czi reader refactor

* rm erroneous include expression

* clang-format

* single lib include with PUBLIC visibility

* compile imgui stdlib

* clang format

* documentation update

centralize `LogLevelToString` to `ILog.hpp`

update docs and examples
2026-02-16 20:36:48 +01:00

84 lines
2.7 KiB
C++

#include "RenderImageManager.hpp"
#include <format>
using namespace std;
/// @brief Updates the collection of rendered images by removing images marked for deletion.
/// This function iterates through the \c keys_to_delete_ list and removes the corresponding images from the collection.
/// It does not acquire the mutex to avoid deadlocks with the `Remove` function.
void pixelarium::application::RenderImageManager::UpdateCollection()
{
for (const auto& key : keys_to_delete_)
{
this->Remove(key);
}
keys_to_delete_.clear();
}
/// @brief Marks a resource for deletion.
/// @param key The ID of the resource to mark for deletion.
void pixelarium::application::RenderImageManager::MarkForDeletion(resources::ResourceKey key)
{
this->log_.Debug(std::format("{} marking key: \"{}\" for deletion.", __PRETTY_FUNCTION__, key));
lock_guard<mutex> guard(this->mut_);
keys_to_delete_.insert(key);
}
/// @brief Removes a render image from the manager.
/// @param key The key of the render image to remove.
/// @return True if the render image was removed, false otherwise.
bool pixelarium::application::RenderImageManager::Remove(resources::ResourceKey key) noexcept
{
bool remove_state{false};
this->log_.Debug(std::format("{} removing key: \"{}\" from renderlist.", __PRETTY_FUNCTION__, key));
{
lock_guard<mutex> guard(this->mut_);
remove_state = this->render_image_map_.erase(key) == 1;
}
return remove_state;
}
/// @brief Adds a resource to the render image map.
/// @param key The ID of the resource to add.
/// @return void. No exception is thrown.
void pixelarium::application::RenderImageManager::Add(resources::ResourceKey key) noexcept
{
// we don't want to add what's already there, render empty images, or failed keys
if (this->render_image_map_.contains(key)
// || this->failed_keys_cache_.contains(key)
)
{
return;
}
auto current_view = this->view_factory_->RenderImage(key);
if (current_view == nullptr)
{
// failed to create view, cache this key to avoid repeated attempts
this->failed_keys_cache_.insert(key);
return;
}
this->log_.Debug(std::format("{}: adding key: \"{}\" to renderlist.", __PRETTY_FUNCTION__, key));
lock_guard<mutex> guard(this->mut_);
// clang-format off
this->render_image_map_.insert(
{
key,
RenderImageStateWrapper
{
.view{ std::move(current_view) },
}
}
);
// clang-format on
}
/// @brief Clears all render images from the manager.
/// @note This function is noexcept.
void pixelarium::application::RenderImageManager::Clear() noexcept { this->render_image_map_.clear(); }