psc/Aethera
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

子图可选

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-20 12:15:01 +08:00
parent 2b8f3ed0e7
commit 69294e2412
1 changed files with 84 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kernel/src/kernel/render_2D.hpp
+84 -42
View File
@@ -98,7 +98,7 @@ protected:
static void run_prepare_data(Attached auto* object) {
using Object = std::remove_pointer_t<decltype(object)>;
auto& private_data = static_cast<typename Object::Private&>(object->d);
if constexpr (requires { private_data.prepare_data(object); }) private_data.prepare_data(object);
private_data.prepare_data(object);
auto callback = [&](auto& value) {
if constexpr (requires { value.after_prepare_data(object); }) value.after_prepare_data(object);
};
@@ -108,6 +108,7 @@ public:
struct Private : Prev_Private {
using Run_Predicate = bool (*)(Root*, bool);
using Rebuild_Predicate = bool (*)(Root*);
using Stage_Run = void (*)(Root*);
using Graph_Builder = tf::Taskflow (*)(Root*, std::pmr::memory_resource*);
using State_Access = State* (*)(Root*);
using State_Notify = void (*)(Root*);
@@ -116,14 +117,16 @@ public:
Run_Predicate paint_predicate;
Rebuild_Predicate prepare_rebuild_predicate;
Rebuild_Predicate paint_rebuild_predicate;
Stage_Run prepare_run;
Stage_Run paint_run;
Graph_Builder prepare_builder;
Graph_Builder paint_builder;
State_Access state_access;
State_Notify state_notify;
};
const Dispatch* dispatch{};
tf::Taskflow prepare_graph;
tf::Taskflow paint_graph;
std::unique_ptr<tf::Taskflow> prepare_graph;
std::unique_ptr<tf::Taskflow> paint_graph;
bool prepare_graph_built{};
bool paint_graph_built{};
bool should_rebuild_prepare_graph(Attached auto*, const State&) {
@@ -138,22 +141,6 @@ public:
bool should_paint(Attached auto*, const State&, bool dirty) {
return dirty;
}
tf::Taskflow build_prepare_graph(Attached auto* object, const State&, std::pmr::memory_resource*) {
tf::Taskflow taskflow;
taskflow.emplace([object] {
run_prepare_data(object);
}).name("renderable.prepare.data");
return taskflow;
}
tf::Taskflow build_paint_graph(Attached auto* object, const State&, std::pmr::memory_resource*) {
using Object = std::remove_pointer_t<decltype(object)>;
tf::Taskflow taskflow;
taskflow.emplace([object] {
auto& private_data = static_cast<typename Object::Private&>(object->d);
private_data.paint(object);
}).name("renderable.paint.data");
return taskflow;
}
void prepare_data(Attached auto*) {}
void after_prepare_data(Attached auto*) {}
void paint(Attached auto*) {}
@@ -183,16 +170,43 @@ private:
auto& private_data = static_cast<typename Object::Private&>(value->d);
return private_data.should_rebuild_paint_graph(value, *value->d.state.current);
},
[](Root* root, std::pmr::memory_resource* resource) {
[](Root* root) {
auto* value = static_cast<Object*>(root);
run_prepare_data(value);
},
[](Root* root) {
auto* value = static_cast<Object*>(root);
auto& private_data = static_cast<typename Object::Private&>(value->d);
return private_data.build_prepare_graph(value, *value->d.state.current, resource);
},
[](Root* root, std::pmr::memory_resource* resource) {
auto* value = static_cast<Object*>(root);
auto& private_data = static_cast<typename Object::Private&>(value->d);
return private_data.build_paint_graph(value, *value->d.state.current, resource);
private_data.paint(value);
},
[]() -> Private::Graph_Builder {
if constexpr (requires(typename Object::Private& private_data, Object* value, const typename Object::State& state, std::pmr::memory_resource* resource) {
{ private_data.build_prepare_graph(value, state, resource) } -> std::same_as<tf::Taskflow>;
}) {
return [](Root* root, std::pmr::memory_resource* resource) {
auto* value = static_cast<Object*>(root);
auto& private_data = static_cast<typename Object::Private&>(value->d);
return private_data.build_prepare_graph(value, *value->d.state.current, resource);
};
}
else {
return nullptr;
}
}(),
[]() -> Private::Graph_Builder {
if constexpr (requires(typename Object::Private& private_data, Object* value, const typename Object::State& state, std::pmr::memory_resource* resource) {
{ private_data.build_paint_graph(value, state, resource) } -> std::same_as<tf::Taskflow>;
}) {
return [](Root* root, std::pmr::memory_resource* resource) {
auto* value = static_cast<Object*>(root);
auto& private_data = static_cast<typename Object::Private&>(value->d);
return private_data.build_paint_graph(value, *value->d.state.current, resource);
};
}
else {
return nullptr;
}
}(),
[](Root* root) {
auto* value = static_cast<Object*>(root);
return static_cast<State*>(value->d.state.current);
@@ -317,20 +331,34 @@ void Scene::Private::after_exchange(Attached auto* object, Prop*, State*, const
auto& state = *dispatch->state_access(root);
state.prepare_graph_rebuilt = false;
state.prepare_execution_time_ns = 0;
bool rebuild = dispatch->prepare_rebuild_predicate(root);
if (!data->prepare_graph_built || rebuild) {
data->prepare_graph = dispatch->prepare_builder(root, detail::task_memory_resource());
data->prepare_graph_built = true;
state.prepare_graph_rebuilt = true;
root->template mark_dirty<Prepare_Data_Tag>();
if (dispatch->prepare_builder) {
bool rebuild = dispatch->prepare_rebuild_predicate(root);
if (!data->prepare_graph_built || rebuild) {
*data->prepare_graph = dispatch->prepare_builder(root, detail::task_memory_resource());
data->prepare_graph_built = true;
state.prepare_graph_rebuilt = true;
root->template mark_dirty<Prepare_Data_Tag>();
}
state.prepare_task_count = data->prepare_graph->num_tasks();
}
else {
state.prepare_task_count = 1;
}
bool dirty = root->template dirty<Prepare_Data_Tag>();
state.prepare_dirty = dirty;
state.prepare_task_count = data->prepare_graph.num_tasks();
state.prepare_executed = dispatch->prepare_predicate(root, dirty);
return state.prepare_executed ? 0 : 1;
}).name("renderable.prepare.condition");
auto prepare_run = taskflow.composed_of(data->prepare_graph).name("renderable.prepare.graph");
tf::Task prepare_run;
if (dispatch->prepare_builder) {
if (!data->prepare_graph) data->prepare_graph = std::make_unique<tf::Taskflow>();
prepare_run = taskflow.composed_of(*data->prepare_graph).name("renderable.prepare.graph");
}
else {
prepare_run = taskflow.emplace([dispatch, root] {
dispatch->prepare_run(root);
}).name("renderable.prepare.data");
}
auto prepare_done = taskflow.emplace([dispatch, root] {
auto& state = *dispatch->state_access(root);
if (!state.prepare_executed) return;
@@ -343,20 +371,34 @@ void Scene::Private::after_exchange(Attached auto* object, Prop*, State*, const
auto& state = *dispatch->state_access(root);
state.paint_graph_rebuilt = false;
state.paint_execution_time_ns = 0;
bool rebuild = dispatch->paint_rebuild_predicate(root);
if (!data->paint_graph_built || rebuild) {
data->paint_graph = dispatch->paint_builder(root, detail::task_memory_resource());
data->paint_graph_built = true;
state.paint_graph_rebuilt = true;
root->template mark_dirty<Paint_Tag>();
if (dispatch->paint_builder) {
bool rebuild = dispatch->paint_rebuild_predicate(root);
if (!data->paint_graph_built || rebuild) {
*data->paint_graph = dispatch->paint_builder(root, detail::task_memory_resource());
data->paint_graph_built = true;
state.paint_graph_rebuilt = true;
root->template mark_dirty<Paint_Tag>();
}
state.paint_task_count = data->paint_graph->num_tasks();
}
else {
state.paint_task_count = 1;
}
bool dirty = root->template dirty<Paint_Tag>();
state.paint_dirty = dirty;
state.paint_task_count = data->paint_graph.num_tasks();
state.paint_executed = dispatch->paint_predicate(root, dirty);
return state.paint_executed ? 0 : 1;
}).name("renderable.paint.condition");
auto paint_run = taskflow.composed_of(data->paint_graph).name("renderable.paint.graph");
tf::Task paint_run;
if (dispatch->paint_builder) {
if (!data->paint_graph) data->paint_graph = std::make_unique<tf::Taskflow>();
paint_run = taskflow.composed_of(*data->paint_graph).name("renderable.paint.graph");
}
else {
paint_run = taskflow.emplace([dispatch, root] {
dispatch->paint_run(root);
}).name("renderable.paint.data");
}
auto paint_done = taskflow.emplace([dispatch, root] {
auto& state = *dispatch->state_access(root);
if (state.paint_executed) root->template take_dirty<Paint_Tag>();