ae/Renderive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

大重构改完

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-12 21:31:02 +08:00
parent 7c00b8565d
commit 15c3d21f2d
73 changed files with 4303 additions and 1727 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Kernel/src/renderive/renderable/base/Renderable_Base.cpp
+88 -33
View File
@@ -1,42 +1,87 @@
#include "Renderable_Base.hpp"
#include <stdexcept>
#include <algorithm>
#include <limits>
#include <stdexcept>
#include "renderive/real_time_data/base/Real_Time_Data_Base.hpp"
#include "renderive/scene/base/Scene_Base.hpp"
namespace {
void advance_revision(std::atomic<std::uint64_t>& revision) noexcept {
std::uint64_t value = revision.load(std::memory_order_relaxed);
while (value != std::numeric_limits<std::uint64_t>::max() &&
!revision.compare_exchange_weak(value, value + 1,
std::memory_order_release,
std::memory_order_relaxed)) {}
}
}
Renderable_Base::Renderable_Base(Scene_Base& scene, Renderable_Configuration configuration)
: memory_domain_(scene.memory_domain_), real_time_data_state_(std::allocate_shared<Real_Time_Data_State>(Scene_Memory_Allocator<Real_Time_Data_State>{memory_domain_}, scene.scene_lifetime_)), discard_stale_frame_on_latest_data_update(real_time_data_state_->discard_stale_frame_on_latest_data_update), layer_node_(this, memory_domain_->resource()), dependency_node_(this, memory_domain_->resource()), configuration_(configuration) {}
: memory_domain_(scene.memory_domain_), real_time_data_state_(std::allocate_shared<Real_Time_Data_State>(Scene_Memory_Allocator<Real_Time_Data_State>{memory_domain_}, scene.scene_lifetime_)), discard_stale_frame_on_latest_data_update(real_time_data_state_->discard_stale_frame_on_latest_data_update), layer_node_(this, memory_domain_->resource()), dependency_node_(this, memory_domain_->resource()), renderable_id_(scene.allocate_renderable_id()), composite_node_id_(scene.allocate_node_id()), configuration_(configuration) {}
Renderable_Base::~Renderable_Base() {
real_time_data_state_->renderable_alive.store(false, std::memory_order_release);
}
void Renderable_Base::render(const Scene_Render_Context&) {}
void Renderable_Base::invalidate_cache() noexcept {
cache_revision_.fetch_add(1, std::memory_order_release);
void Renderable_Base::invalidate_prepare() noexcept {
advance_revision(prepare_revision_);
}
std::uint64_t Renderable_Base::cache_revision() const noexcept {
return cache_revision_.load(std::memory_order_acquire);
void Renderable_Base::invalidate_paint() noexcept {
advance_revision(paint_revision_);
}
std::uint64_t Renderable_Base::rendered_cache_revision() const noexcept {
return rendered_cache_revision_.load(std::memory_order_acquire);
std::uint64_t Renderable_Base::prepare_revision() const noexcept {
return prepare_revision_.load(std::memory_order_acquire);
}
bool Renderable_Base::cache_valid() const noexcept {
return configuration().cache_enabled && rendered_cache_revision() == cache_revision();
std::uint64_t Renderable_Base::prepared_revision() const noexcept {
return prepared_revision_.load(std::memory_order_acquire);
}
void Renderable_Base::rebuild_task_graph() noexcept {
std::uint64_t Renderable_Base::paint_revision() const noexcept {
return paint_revision_.load(std::memory_order_acquire);
}
std::uint64_t Renderable_Base::painted_revision() const noexcept {
return painted_revision_.load(std::memory_order_acquire);
}
bool Renderable_Base::prepare_cache_valid() const noexcept {
const std::uint64_t revision = prepare_revision();
return revision != std::numeric_limits<std::uint64_t>::max() &&
configuration().cache_enabled && prepared_revision() == revision;
}
bool Renderable_Base::paint_cache_valid() const noexcept {
const std::uint64_t revision = paint_revision();
return revision != std::numeric_limits<std::uint64_t>::max() &&
configuration().cache_enabled && prepare_cache_valid() &&
painted_revision() == revision &&
painted_prepare_revision_.load(std::memory_order_acquire) == prepared_revision();
}
void Renderable_Base::rebuild_render_graph() noexcept {
{
std::lock_guard lock(task_graph_mutex_);
++task_graph_revision_;
std::lock_guard lock(render_graph_mutex_);
render_graph_dirty_ = true;
}
invalidate_cache();
invalidate_prepare();
}
std::shared_ptr<const Renderable_Task_Graph> Renderable_Base::task_graph() {
std::lock_guard lock(task_graph_mutex_);
if (built_task_graph_revision_ != task_graph_revision_) {
auto graph = std::allocate_shared<Renderable_Task_Graph>(Scene_Memory_Allocator<Renderable_Task_Graph>{memory_domain_}, memory_domain_->resource());
build_task_graph(*graph);
task_graph_ = std::move(graph);
built_task_graph_revision_ = task_graph_revision_;
std::shared_ptr<const Renderable_Graph> Renderable_Base::render_graph() {
std::lock_guard lock(render_graph_mutex_);
if (render_graph_dirty_) {
std::unordered_map<std::string, Render_Node_Id> next_identities;
Renderable_Graph_Builder builder(renderable_id_, [this, &next_identities](
std::string_view key) {
const std::string logical_key(key);
if (next_identities.contains(logical_key))
throw std::invalid_argument("duplicate render node logical key");
const auto current = node_identities_.find(logical_key);
const Render_Node_Id node_id = current == node_identities_.end()
? scene().allocate_node_id()
: current->second;
next_identities.emplace(logical_key, node_id);
return node_id;
});
build_prepare_graph(builder);
build_paint_graph(builder);
auto graph = std::make_shared<Renderable_Graph>(std::move(builder).finish());
node_identities_ = std::move(next_identities);
render_graph_ = std::move(graph);
render_graph_dirty_ = false;
}
return task_graph_;
return render_graph_;
}
std::uint64_t Renderable_Base::renderable_id() const noexcept {
return renderable_id_;
}
std::pmr::memory_resource& Renderable_Base::memory_resource() const noexcept {
return memory_domain_->resource();
@@ -52,23 +97,33 @@ Renderable_Configuration Renderable_Base::configuration() const noexcept {
std::lock_guard lock(configuration_mutex_);
return configuration_;
}
void Renderable_Base::build_task_graph(Renderable_Task_Graph& graph) {
graph.emplace([this](const Scene_Render_Context& context) {
render(context);
}, "render");
void Renderable_Base::build_prepare_graph(Renderable_Graph_Builder& builder) {
builder.emplace("prepare", "Prepare", Render_Node_Kind::prepare,
[this](const Scene_Render_Context& context) {
prepare(context);
});
}
Render_State_View Renderable_Base::render_state_view() const noexcept {
void Renderable_Base::build_paint_graph(Renderable_Graph_Builder&) {}
void Renderable_Base::prepare(const Scene_Render_Context&) {}
Render_State_View Renderable_Base::render_state_view() noexcept {
return {};
}
Real_Time_Data_Binding Renderable_Base::bind_real_time_data(Real_Time_Data_Base& data) {
return data.bind_renderable(*this);
}
bool Renderable_Base::requires_render() const noexcept {
const auto config = configuration();
return !config.cache_enabled || rendered_cache_revision() != cache_revision();
bool Renderable_Base::requires_prepare() const noexcept {
return !prepare_cache_valid();
}
void Renderable_Base::mark_rendered(std::uint64_t revision) noexcept {
rendered_cache_revision_.store(revision, std::memory_order_release);
bool Renderable_Base::requires_paint() const noexcept {
return !paint_cache_valid();
}
void Renderable_Base::mark_prepared(std::uint64_t revision) noexcept {
prepared_revision_.store(revision, std::memory_order_release);
}
void Renderable_Base::mark_painted(std::uint64_t paint_revision,
std::uint64_t prepare_revision) noexcept {
painted_prepare_revision_.store(prepare_revision, std::memory_order_release);
painted_revision_.store(paint_revision, std::memory_order_release);
}
void Renderable_Base::set_configuration(Renderable_Configuration configuration) noexcept {
std::lock_guard lock(configuration_mutex_);