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-17 13:32:03 +08:00
parent 7c6b0f3e1e
commit 6a1980b920
56 changed files with 1642 additions and 649 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Kernel/src/renderive/base/observer/concept/Observer.hpp
+1 -1
View File
@@ -3,7 +3,7 @@
#include <cstdint>
#include <type_traits>
template <class That>
concept Observation_Struct = std::is_class_v<That>;
concept Observation_Struct = std::is_class_v<That> && std::copyable<That>;
template <class That>
concept Observer_Enable_Flag = requires {
{ That::enabled } -> std::convertible_to<bool>;
Kernel/src/renderive/frame_control/Inheritance.hpp
+19 -5
View File
@@ -34,16 +34,30 @@ namespace renderive::frame_control {
template <class Layer, class Parent>
struct strategy_base : Parent {
protected:
struct State_Layer
: frame_control_inheritance::State_Node<
State_Layer, typename Parent::State_Layer> {};
struct State : Parent::template next_State<State> {};
struct Impl : Parent::template next_Impl<Impl> {
using Impl_Base = typename Parent::template next_Impl<Impl>;
using Impl_Base::Impl_Base;
};
template <class Next>
using next_State = frame_control_inheritance::State_Node<Next, State_Layer>;
using next_State = frame_control_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl = frame_control_inheritance::Impl_Node<
Next, typename Parent::Impl>;
Next, Impl>;
static_assert(inheritance::Defines_Chain_Layer<
State, typename Parent::template next_State<State>,
next_State<inheritance::Chain_Probe>,
frame_control_inheritance::State_Node<
inheritance::Chain_Probe, State>>);
static_assert(inheritance::Defines_Chain_Layer<
Impl, typename Parent::template next_Impl<Impl>,
next_Impl<inheritance::Chain_Probe>,
frame_control_inheritance::Impl_Node<
inheritance::Chain_Probe, Impl>>);
using Parent::Parent;
};
Kernel/src/renderive/frame_control/base/Frame_Control_Strategy_Base.hpp
+9 -2
View File
@@ -36,12 +36,19 @@ public:
return static_cast<std::uint64_t>(interval_ns);
}
protected:
struct State_Layer
: renderive::frame_control_inheritance::State_Root<State_Layer> {};
struct State
: renderive::frame_control_inheritance::State_Root<State> {};
struct Impl
: renderive::frame_control_inheritance::Impl_Root<Impl> {};
template <class Next>
using next_State =
renderive::frame_control_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl =
renderive::frame_control_inheritance::Impl_Node<Next, Impl>;
Frame_Control_Strategy_Base() : impl_(std::make_unique<Impl>()) {}
explicit Frame_Control_Strategy_Base(std::unique_ptr<Impl> impl)
: impl_(std::move(impl)) {}
Kernel/src/renderive/frame_control/strategy/flow/Flow_Refresh_Strategy.hpp
+13
View File
@@ -117,6 +117,19 @@ public:
private:
struct Impl;
template <class Next>
using next_State =
renderive::frame_control_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl =
renderive::frame_control_inheritance::Impl_Node<Next, Impl>;
static_assert(renderive::inheritance::Defines_Chain_Layer<
State, Control_Base::template next_State<State>,
next_State<renderive::inheritance::Chain_Probe>,
renderive::frame_control_inheritance::State_Node<
renderive::inheritance::Chain_Probe, State>>);
Impl& impl() noexcept { return this->template d_func<Impl>(); }
const Impl& impl() const noexcept {
return this->template d_func<Impl>();
Kernel/src/renderive/frame_control/strategy/flow/Flow_Refresh_Strategy.inl
+6
View File
@@ -5,6 +5,12 @@ struct Flow_Refresh_Strategy<Scene, Mutex, Observer>::Impl
: Control_Base::template next_Impl<Impl> {
using Impl_Base = Control_Base::template next_Impl<Impl>;
using Frame_Ptr = Memory_Resource_Unique_Ptr<Frame>;
static_assert(renderive::inheritance::Defines_Chain_Layer<
Impl, Control_Base::template next_Impl<Impl>,
Flow_Refresh_Strategy::template next_Impl<
renderive::inheritance::Chain_Probe>,
renderive::frame_control_inheritance::Impl_Node<
renderive::inheritance::Chain_Probe, Impl>>);
Impl(Flow_Refresh_Strategy& owner, std::pmr::memory_resource& resource,
std::size_t capacity)
Kernel/src/renderive/frame_control/strategy/low_latency/Low_Latency_Strategy.hpp
+13
View File
@@ -187,6 +187,19 @@ public:
private:
struct Impl;
template <class Next>
using next_State =
renderive::frame_control_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl =
renderive::frame_control_inheritance::Impl_Node<Next, Impl>;
static_assert(renderive::inheritance::Defines_Chain_Layer<
State, Control_Base::template next_State<State>,
next_State<renderive::inheritance::Chain_Probe>,
renderive::frame_control_inheritance::State_Node<
renderive::inheritance::Chain_Probe, State>>);
Impl& impl() noexcept { return this->template d_func<Impl>(); }
const Impl& impl() const noexcept {
return this->template d_func<Impl>();
Kernel/src/renderive/frame_control/strategy/low_latency/Low_Latency_Strategy.inl
+6
View File
@@ -7,6 +7,12 @@ template <class Scene, Mutex_Type Mutex, class Observer>
struct Low_Latency_Strategy<Scene, Mutex, Observer>::Impl
: Control_Base::template next_Impl<Impl> {
using Impl_Base = Control_Base::template next_Impl<Impl>;
static_assert(renderive::inheritance::Defines_Chain_Layer<
Impl, Control_Base::template next_Impl<Impl>,
Low_Latency_Strategy::template next_Impl<
renderive::inheritance::Chain_Probe>,
renderive::frame_control_inheritance::Impl_Node<
renderive::inheritance::Chain_Probe, Impl>>);
Impl(Low_Latency_Strategy& owner, Configuration configuration)
: Impl_Base(), owner_(&owner), paint_(&frames_[0]),
Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.hpp
+13
View File
@@ -117,6 +117,19 @@ public:
void on_real_time_data_update(const Real_Time_Data_Observation& observation) override;
private:
struct Impl;
template <class Next>
using next_State =
renderive::frame_control_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl =
renderive::frame_control_inheritance::Impl_Node<Next, Impl>;
static_assert(renderive::inheritance::Defines_Chain_Layer<
State, Control_Base::template next_State<State>,
next_State<renderive::inheritance::Chain_Probe>,
renderive::frame_control_inheritance::State_Node<
renderive::inheritance::Chain_Probe, State>>);
Impl& impl() noexcept {
return this->template d_func<Impl>();
}
Kernel/src/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy.inl
+6
View File
@@ -3,6 +3,12 @@ template <class Scene, Mutex_Type Mutex, class Observer>
struct Manual_Refresh_Strategy<Scene, Mutex, Observer>::Impl
: Control_Base::template next_Impl<Impl> {
using Impl_Base = Control_Base::template next_Impl<Impl>;
static_assert(renderive::inheritance::Defines_Chain_Layer<
Impl, Control_Base::template next_Impl<Impl>,
Manual_Refresh_Strategy::template next_Impl<
renderive::inheritance::Chain_Probe>,
renderive::frame_control_inheritance::Impl_Node<
renderive::inheritance::Chain_Probe, Impl>>);
explicit Impl(Manual_Refresh_Strategy& owner)
: Impl_Base(), owner_(&owner), paint_(&frames_[0]),
Kernel/src/renderive/inheritance/Registry.hpp
+14
View File
@@ -1,5 +1,6 @@
#pragma once
#include <concepts>
#include <cstddef>
#include <limits>
#include <type_traits>
@@ -145,6 +146,19 @@ struct Type_Root {
using Inheritance_Registry = Registry<>;
};
struct Chain_Probe {};
template <class Entity, class Parent_Next>
concept Inherits_Chain_Parent = requires(Entity* entity) {
static_cast<Parent_Next*>(entity);
};
template <class Entity, class Parent_Next, class Next_Entity,
class Expected_Next>
concept Defines_Chain_Layer =
Inherits_Chain_Parent<Entity, Parent_Next> &&
std::same_as<Next_Entity, Expected_Next>;
template <class Layer, class Parent, class Chain,
std::size_t Requested_Position = Automatic_Position>
struct Type_Node : Parent {
Kernel/src/renderive/renderable/Inheritance.hpp
+76 -23
View File
@@ -11,6 +11,7 @@ namespace renderive::renderable_inheritance {
struct Builder_Chain {};
struct State_Chain {};
struct Impl_Chain {};
struct Observer_Chain {};
struct Builder_Access {
class Key {
@@ -37,9 +38,9 @@ struct Builder_Node
using Builder_Base::Builder_Base;
};
template <class Layer, class Parent, class Business_Builder>
template <class Layer, class Parent_Next, class Business_Builder>
struct Builder
: Builder_Node<Layer, Parent>, Business_Builder {
: Parent_Next, Business_Builder {
using Business_Builder::Business_Builder;
};
@@ -54,13 +55,22 @@ struct State_Node : inheritance::Type_Node<Layer, Parent, State_Chain> {
};
template <class Layer>
struct Observer_Root {
struct Observer_Root
: inheritance::Type_Node<Layer, inheritance::Type_Root,
Observer_Chain> {
using Observer_Base = inheritance::Type_Node<
Layer, inheritance::Type_Root, Observer_Chain>;
using Owner = Layer;
using Observer_Base::Observer_Base;
};
template <class Layer, class Parent>
struct Observer_Node : Parent {
struct Observer_Node
: inheritance::Type_Node<Layer, Parent, Observer_Chain> {
using Observer_Base =
inheritance::Type_Node<Layer, Parent, Observer_Chain>;
using Owner = Layer;
using Observer_Base::Observer_Base;
};
template <class Layer, class Event>
@@ -69,11 +79,10 @@ struct Observer_Handler {
static void handle(Layer& layer, const Event& event)
requires requires {
typename Layer::Observer;
Layer::Observer::handle(layer, event);
layer.handle_observation(event);
}
{
Layer::Observer::handle(layer, event);
layer.handle_observation(event);
}
};
@@ -96,7 +105,6 @@ struct Impl_Node
typename Parent::Renderable_Event>;
using Renderable_Event = typename Parent::Renderable_Event;
using Handler = Observer_Handler<Layer, Renderable_Event>;
using next_Observer = Observer_Node<Layer, typename Parent::Observer>;
using Impl_Base::Impl_Base;
};
@@ -109,32 +117,72 @@ struct render_base;
template <class Layer, class Parent>
struct render_base<Layer, Parent, true> : Parent {
public:
struct Builder : renderable_inheritance::Builder_Root<Builder> {};
template <class Next>
using next_Builder = renderable_inheritance::Builder_Node<Next, Builder>;
protected:
struct Builder_Layer
: renderable_inheritance::Builder_Root<Builder_Layer> {};
struct State : renderable_inheritance::State_Root<State> {};
template <class Next>
using next_State = renderable_inheritance::State_Node<Next, State>;
using Parent::Parent;
};
template <class Layer, class Parent>
struct render_base<Layer, Parent, false> : Parent {
public:
struct Builder : Parent::template next_Builder<Builder> {};
protected:
struct Builder_Layer
: renderable_inheritance::Builder_Node<
Builder_Layer, typename Parent::Builder_Layer> {};
struct State : Parent::template next_State<State> {};
struct Impl : Parent::template next_Impl<Impl> {
using Impl_Base = typename Parent::template next_Impl<Impl>;
using Impl_Base::Impl_Base;
};
struct Observer : Parent::template next_Observer<Observer> {};
template <class Next>
using next_State = renderable_inheritance::State_Node<
Next, typename Parent::State>;
Next, State>;
template <class Next>
using next_Impl = renderable_inheritance::Impl_Node<
Next, typename Parent::Impl>;
Next, Impl>;
template <class Next>
using next_Observer = renderable_inheritance::Observer_Node<
Next, typename Parent::Observer>;
Next, Observer>;
template <class Next>
using next_Builder = renderable_inheritance::Builder_Node<
Next, Builder>;
static_assert(inheritance::Defines_Chain_Layer<
Builder, typename Parent::template next_Builder<Builder>,
next_Builder<inheritance::Chain_Probe>,
renderable_inheritance::Builder_Node<
inheritance::Chain_Probe, Builder>>);
static_assert(inheritance::Defines_Chain_Layer<
State, typename Parent::template next_State<State>,
next_State<inheritance::Chain_Probe>,
renderable_inheritance::State_Node<
inheritance::Chain_Probe, State>>);
static_assert(inheritance::Defines_Chain_Layer<
Impl, typename Parent::template next_Impl<Impl>,
next_Impl<inheritance::Chain_Probe>,
renderable_inheritance::Impl_Node<
inheritance::Chain_Probe, Impl>>);
static_assert(inheritance::Defines_Chain_Layer<
Observer, typename Parent::template next_Observer<Observer>,
next_Observer<inheritance::Chain_Probe>,
renderable_inheritance::Observer_Node<
inheritance::Chain_Probe, Observer>>);
using Parent::Parent;
};
@@ -143,24 +191,29 @@ template <class Control>
struct attach : Control {
using State = typename Control::State;
using Properties = State;
using Observer = typename Control::Observer;
using Self = attach;
protected:
struct Builder_Layer
: renderable_inheritance::Builder_Node<
Builder_Layer, typename Control::Builder_Layer> {};
public:
struct Builder
: renderable_inheritance::Builder<
Builder, Builder_Layer,
Builder, typename Control::template next_Builder<Builder>,
typename Control::template Business_Builder<Self, State>> {
using Builder_Base = renderable_inheritance::Builder<
Builder, Builder_Layer,
Builder, typename Control::template next_Builder<Builder>,
typename Control::template Business_Builder<Self, State>>;
using Builder_Base::Builder_Base;
};
template <class Next>
using next_Builder = renderable_inheritance::Builder_Node<Next, Builder>;
static_assert(inheritance::Defines_Chain_Layer<
Builder, typename Control::template next_Builder<Builder>,
next_Builder<inheritance::Chain_Probe>,
renderable_inheritance::Builder_Node<
inheritance::Chain_Probe, Builder>>);
template <auto Member, class Value>
Self& set(Value&& value) {
if constexpr (requires(Self& self, Value&& input) {
Kernel/src/renderive/scene/Inheritance.hpp
+127 -18
View File
@@ -2,12 +2,26 @@
#include "renderive/inheritance/Inheritance.hpp"
#include <concepts>
#include <functional>
#include <memory>
#include <utility>
namespace renderive::scene_inheritance {
struct Builder_Chain {};
struct State_Chain {};
struct Impl_Chain {};
struct Editor_Chain {};
struct Observer_Chain {};
struct Builder_Access {
class Key {
Key() = default;
friend struct Builder_Access;
};
template <class Product, class... Args>
[[nodiscard]] static std::unique_ptr<Product> make(Args&&... args) {
return std::unique_ptr<Product>(
new Product(Key{}, std::forward<Args>(args)...));
}
};
template <class Layer>
struct Builder_Root
: inheritance::Type_Node<Layer, inheritance::Type_Root, Builder_Chain> {};
@@ -16,6 +30,11 @@ struct Builder_Node : inheritance::Type_Node<Layer, Parent, Builder_Chain> {
using Builder_Base = inheritance::Type_Node<Layer, Parent, Builder_Chain>;
using Builder_Base::Builder_Base;
};
template <class Layer, class Parent_Next, class Business_Builder>
struct Builder
: Parent_Next, Business_Builder {
using Business_Builder::Business_Builder;
};
template <class Layer>
struct State_Root
: inheritance::Type_Node<Layer, inheritance::Type_Root, State_Chain> {};
@@ -33,21 +52,28 @@ struct Editor_Node : inheritance::Type_Node<Layer, Parent, Editor_Chain> {
using Editor_Base::Editor_Base;
};
template <class Layer>
struct Observer_Root {
struct Observer_Root
: inheritance::Type_Node<Layer, inheritance::Type_Root, Observer_Chain> {
using Observer_Base = inheritance::Type_Node<
Layer, inheritance::Type_Root, Observer_Chain>;
using Owner = Layer;
using Observer_Base::Observer_Base;
};
template <class Layer, class Parent>
struct Observer_Node : Parent {
struct Observer_Node
: inheritance::Type_Node<Layer, Parent, Observer_Chain> {
using Observer_Base =
inheritance::Type_Node<Layer, Parent, Observer_Chain>;
using Owner = Layer;
using Observer_Base::Observer_Base;
};
template <class Layer, class Event>
struct Observer_Handler {
using Owner = Layer;
static void handle(Layer& layer, const Event& event) requires requires {
typename Layer::Observer;
Layer::Observer::handle(layer, event);
layer.handle_observation(event);
} {
Layer::Observer::handle(layer, event);
layer.handle_observation(event);
}
};
template <class Layer, class Event>
@@ -70,7 +96,6 @@ struct Impl_Node
typename Parent::Scene_Event>;
using Scene_Event = typename Parent::Scene_Event;
using Handler = Observer_Handler<Layer, Scene_Event>;
using next_Observer = Observer_Node<Layer, typename Parent::Observer>;
using Impl_Base::Impl_Base;
};
} // namespace renderive::scene_inheritance
@@ -102,25 +127,109 @@ public:
});
}
struct Observer
: scene_inheritance::Observer_Node<Layer,
typename Parent::Observer> {};
: Parent::template next_Observer<Observer> {};
protected:
struct Builder_Layer
: scene_inheritance::Builder_Node<
Builder_Layer, typename Parent::Builder_Layer> {};
struct State_Layer
: scene_inheritance::State_Node<
State_Layer, typename Parent::State_Layer> {};
struct Builder : Parent::template next_Builder<Builder> {};
struct State : Parent::template next_State<State> {};
struct Impl : Parent::template next_Impl<Impl> {
using Impl_Base = typename Parent::template next_Impl<Impl>;
using Impl_Base::Impl_Base;
};
class Renderable_Editor : public Parent::template next_Editor<
Renderable_Editor> {
using Editor_Base = typename Parent::template next_Editor<
Renderable_Editor>;
using Editor_Base::Editor_Base;
};
template <class Next>
using next_State = scene_inheritance::State_Node<Next, State_Layer>;
using next_State = scene_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl = scene_inheritance::Impl_Node<Next, typename Parent::Impl>;
using next_Impl = scene_inheritance::Impl_Node<Next, Impl>;
template <class Next>
using next_Editor = scene_inheritance::Editor_Node<
Next, typename Parent::Renderable_Editor>;
Next, Renderable_Editor>;
template <class Next>
using next_Builder = scene_inheritance::Builder_Node<
Next, Builder_Layer>;
Next, Builder>;
template <class Next>
using next_Observer = scene_inheritance::Observer_Node<
Next, Observer>;
static_assert(inheritance::Defines_Chain_Layer<
Builder, typename Parent::template next_Builder<Builder>,
next_Builder<inheritance::Chain_Probe>,
scene_inheritance::Builder_Node<inheritance::Chain_Probe, Builder>>);
static_assert(inheritance::Defines_Chain_Layer<
State, typename Parent::template next_State<State>,
next_State<inheritance::Chain_Probe>,
scene_inheritance::State_Node<inheritance::Chain_Probe, State>>);
static_assert(inheritance::Defines_Chain_Layer<
Impl, typename Parent::template next_Impl<Impl>,
next_Impl<inheritance::Chain_Probe>,
scene_inheritance::Impl_Node<inheritance::Chain_Probe, Impl>>);
static_assert(inheritance::Defines_Chain_Layer<
Renderable_Editor,
typename Parent::template next_Editor<Renderable_Editor>,
next_Editor<inheritance::Chain_Probe>,
scene_inheritance::Editor_Node<
inheritance::Chain_Probe, Renderable_Editor>>);
static_assert(inheritance::Defines_Chain_Layer<
Observer, typename Parent::template next_Observer<Observer>,
next_Observer<inheritance::Chain_Probe>,
scene_inheritance::Observer_Node<
inheritance::Chain_Probe, Observer>>);
using Parent::Parent;
};
template <class Control>
struct attach : Control {
using State = typename Control::State;
using Properties = State;
using Observer = typename Control::Observer;
using Self = attach;
public:
struct Builder
: scene_inheritance::Builder<
Builder, typename Control::template next_Builder<Builder>,
typename Control::template Business_Builder<Self, State>> {
using Builder_Base = scene_inheritance::Builder<
Builder, typename Control::template next_Builder<Builder>,
typename Control::template Business_Builder<Self, State>>;
using Builder_Base::Builder_Base;
};
template <class Next>
using next_Builder = scene_inheritance::Builder_Node<Next, Builder>;
static_assert(inheritance::Defines_Chain_Layer<
Builder, typename Control::template next_Builder<Builder>,
next_Builder<inheritance::Chain_Probe>,
scene_inheritance::Builder_Node<inheritance::Chain_Probe, Builder>>);
template <auto Member, class Value>
Self& set(Value&& value) {
Control::template set<Member>(std::forward<Value>(value));
return *this;
}
template <auto Member>
[[nodiscard]] auto get() const {
return Control::template get<Member>();
}
template <class Update>
Self& update(Update&& operation) {
Control::update(std::forward<Update>(operation));
return *this;
}
private:
template <class... Args>
explicit attach(scene_inheritance::Builder_Access::Key,
Args&&... args)
: Control(std::forward<Args>(args)...) {}
friend struct scene_inheritance::Builder_Access;
};
} // namespace renderive::scene
Kernel/src/renderive/scene/Scene_Builder.hpp
+61
View File
@@ -0,0 +1,61 @@
#pragma once
#include "renderive/base/property/Concepts.hpp"
#include "renderive/base/property/Validators.hpp"
#include "renderive/scene/Inheritance.hpp"
#include <concepts>
#include <functional>
#include <memory>
#include <utility>
namespace renderive::scene {
template <Property_Product Product_Type, Property_Set Properties_Type,
Property_Validator<Properties_Type> Validator_Type =
No_Property_Validator<Properties_Type>>
struct Scene_Builder {
using Product = Product_Type;
using Properties = Properties_Type;
using Validator = Validator_Type;
using Self = Scene_Builder;
Scene_Builder()
requires std::default_initializable<Properties> &&
std::default_initializable<Validator>
= default;
explicit Scene_Builder(Properties properties)
requires std::default_initializable<Validator>
: properties_(std::move(properties)) {}
Scene_Builder(Properties properties, Validator validator)
: properties_(std::move(properties)),
validator_(std::move(validator)) {}
template <auto Member,
Property_Member_Assignable<Properties, Member> Value>
Self& set(Value&& value) {
properties_.*Member = std::forward<Value>(value);
return *this;
}
template <Property_Configurator<Properties> Configure>
Self& configure(Configure&& configure) {
std::invoke(std::forward<Configure>(configure), properties_);
return *this;
}
template <class... Args>
[[nodiscard]] std::unique_ptr<Product> build(Args&&... args) const {
validator_(properties_);
return scene_inheritance::Builder_Access::make<Product>(
properties_, std::forward<Args>(args)...);
}
private:
Properties properties_{};
[[no_unique_address]] Validator validator_{};
};
} // namespace renderive::scene
Kernel/src/renderive/scene/base/Scene_Base.cpp
+1 -2
View File
@@ -468,8 +468,7 @@ Scene_2D_Base::Scene_2D_Base() : Scene_2D_Base(*std::pmr::get_default_resource()
Scene_2D_Base::Scene_2D_Base(std::pmr::memory_resource& memory_resource) : Scene_2D_Base(memory_resource, std::make_unique<Impl>(memory_resource)) {}
Scene_2D_Base::Scene_2D_Base(std::pmr::memory_resource& memory_resource,
std::unique_ptr<Scene_Base::Impl> impl) : Scene_Base(memory_resource, std::move(impl)) {}
Scene_2D_Base::Impl::Impl(std::pmr::memory_resource& memory_resource) : renderive::scene_inheritance::Impl_Node<
Impl, Scene_Base::Impl>(memory_resource),
Scene_2D_Base::Impl::Impl(std::pmr::memory_resource& memory_resource) : Scene_Base::next_Impl<Impl>(memory_resource),
display_resolver_(this->memory_resource()) {}
Scene_2D_Base::Attach_Builder Scene_2D_Base::attach_builder() {
return Attach_Builder(*this);
Kernel/src/renderive/scene/base/Scene_Base.hpp
+145 -35
View File
@@ -68,6 +68,9 @@ public:
class Renderable_Editor
: public renderive::scene_inheritance::Editor_Root<Renderable_Editor> {
public:
template <class Next>
using next_Editor =
renderive::scene_inheritance::Editor_Node<Next, Renderable_Editor>;
[[nodiscard]] Scene_Edit_Error attach(Renderable renderable);
[[nodiscard]] Scene_Edit_Error detach(const Renderable& renderable);
[[nodiscard]] Scene_Edit_Error set_dependency_parent(const Renderable& child, const Renderable& parent);
@@ -88,6 +91,9 @@ public:
class Attach_Builder
: public renderive::scene_inheritance::Builder_Root<Attach_Builder> {
public:
template <class Next>
using next_Builder =
renderive::scene_inheritance::Builder_Node<Next, Attach_Builder>;
Attach_Builder(const Attach_Builder&) = delete;
Attach_Builder& operator=(const Attach_Builder&) = delete;
Attach_Builder(Attach_Builder&&) = delete;
@@ -166,16 +172,32 @@ public:
[[nodiscard]] auto frame_control_strategy() -> std::shared_ptr<Frame_Control_Strategy_Base>;
[[nodiscard]] auto frame_control_strategy() const -> std::shared_ptr<const Frame_Control_Strategy_Base>;
struct Observer
: renderive::scene_inheritance::Observer_Root<Scene_Base> {};
: renderive::scene_inheritance::Observer_Root<Observer> {};
protected:
Scene_Base();
explicit Scene_Base(std::pmr::memory_resource& upstream_memory_resource);
virtual ~Scene_Base();
struct Builder_Layer
: renderive::scene_inheritance::Builder_Root<Builder_Layer> {};
struct State_Layer
: renderive::scene_inheritance::State_Root<State_Layer> {};
struct Builder
: renderive::scene_inheritance::Builder_Root<Builder> {};
struct State
: renderive::scene_inheritance::State_Root<State> {};
class Impl;
template <class Next>
using next_Builder =
renderive::scene_inheritance::Builder_Node<Next, Builder>;
template <class Next>
using next_State =
renderive::scene_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl =
renderive::scene_inheritance::Impl_Node<Next, Impl>;
template <class Next>
using next_Observer =
renderive::scene_inheritance::Observer_Node<Next, Observer>;
template <class Next>
using next_Editor =
renderive::scene_inheritance::Editor_Node<Next, Renderable_Editor>;
Scene_Base(std::pmr::memory_resource& upstream_memory_resource,
std::unique_ptr<Impl> impl);
template <class Implementation = Impl>
@@ -194,30 +216,34 @@ private:
class Scene_2D_Base : public Scene_Base {
public:
class Renderable_Editor
: public renderive::scene_inheritance::Editor_Node<
Renderable_Editor, Scene_Base::Renderable_Editor> {
: public Scene_Base::Renderable_Editor::next_Editor<Renderable_Editor> {
public:
template <class Next>
using next_Editor =
renderive::scene_inheritance::Editor_Node<Next, Renderable_Editor>;
[[nodiscard]] Scene_Edit_Error set_display_parent(const Renderable& child, const Renderable& parent);
[[nodiscard]] Scene_Edit_Error add_display_parent(const Renderable& child, const Renderable& parent);
[[nodiscard]] Scene_Edit_Error clear_display_parent(const Renderable& child);
private:
explicit Renderable_Editor(Scene_2D_Base& scene) : renderive::scene_inheritance::Editor_Node<
Renderable_Editor, Scene_Base::Renderable_Editor>(scene),
explicit Renderable_Editor(Scene_2D_Base& scene) : Scene_Base::Renderable_Editor::next_Editor<
Renderable_Editor>(scene),
scene_2d_(scene) {}
Scene_2D_Base& scene_2d_;
friend class Scene_2D_Base;
friend class Attach_Builder;
};
class Attach_Builder
: public renderive::scene_inheritance::Builder_Node<
Attach_Builder, Scene_Base::Attach_Builder> {
: public Scene_Base::Attach_Builder::next_Builder<Attach_Builder> {
public:
template <class Next>
using next_Builder =
renderive::scene_inheritance::Builder_Node<Next, Attach_Builder>;
[[nodiscard]] Scene_Edit_Error set_display_parent(const Renderable& child, const Renderable& parent);
[[nodiscard]] Scene_Edit_Error add_display_parent(const Renderable& child, const Renderable& parent);
[[nodiscard]] Scene_Edit_Error clear_display_parent(const Renderable& child);
private:
explicit Attach_Builder(Scene_2D_Base& scene) : renderive::scene_inheritance::Builder_Node<
Attach_Builder, Scene_Base::Attach_Builder>(scene),
explicit Attach_Builder(Scene_2D_Base& scene) : Scene_Base::Attach_Builder::next_Builder<
Attach_Builder>(scene),
scene_2d_(scene) {}
Scene_2D_Base& scene_2d_;
friend class Scene_2D_Base;
@@ -228,16 +254,53 @@ public:
Attach_Builder attach_builder();
[[nodiscard]] Edit_Operation edit_renderables(Renderable_Edit edit);
struct Observer
: renderive::scene_inheritance::Observer_Node<
Scene_2D_Base, Scene_Base::Observer> {};
: Scene_Base::next_Observer<Observer> {};
protected:
struct Builder_Layer
: renderive::scene_inheritance::Builder_Node<
Builder_Layer, Scene_Base::Builder_Layer> {};
struct State_Layer
: renderive::scene_inheritance::State_Node<
State_Layer, Scene_Base::State_Layer> {};
struct Builder : Scene_Base::next_Builder<Builder> {};
struct State : Scene_Base::next_State<State> {};
struct Impl;
template <class Next>
using next_Builder =
renderive::scene_inheritance::Builder_Node<Next, Builder>;
template <class Next>
using next_State =
renderive::scene_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl =
renderive::scene_inheritance::Impl_Node<Next, Impl>;
template <class Next>
using next_Observer =
renderive::scene_inheritance::Observer_Node<Next, Observer>;
template <class Next>
using next_Editor =
renderive::scene_inheritance::Editor_Node<Next, Renderable_Editor>;
static_assert(renderive::inheritance::Defines_Chain_Layer<
Builder, Scene_Base::next_Builder<Builder>,
next_Builder<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Builder_Node<
renderive::inheritance::Chain_Probe, Builder>>);
static_assert(renderive::inheritance::Defines_Chain_Layer<
State, Scene_Base::next_State<State>,
next_State<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::State_Node<
renderive::inheritance::Chain_Probe, State>>);
static_assert(renderive::inheritance::Defines_Chain_Layer<
Observer, Scene_Base::next_Observer<Observer>,
next_Observer<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Observer_Node<
renderive::inheritance::Chain_Probe, Observer>>);
static_assert(renderive::inheritance::Defines_Chain_Layer<
Renderable_Editor,
Scene_Base::Renderable_Editor::next_Editor<Renderable_Editor>,
next_Editor<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Editor_Node<
renderive::inheritance::Chain_Probe, Renderable_Editor>>);
static_assert(renderive::inheritance::Defines_Chain_Layer<
Attach_Builder,
Scene_Base::Attach_Builder::next_Builder<Attach_Builder>,
Attach_Builder::next_Builder<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Builder_Node<
renderive::inheritance::Chain_Probe, Attach_Builder>>);
Scene_2D_Base(std::pmr::memory_resource& memory_resource,
std::unique_ptr<Scene_Base::Impl> impl);
private:
@@ -245,33 +308,80 @@ private:
};
class Scene_3D_Base : public Scene_Base {
public:
class Renderable_Editor : public renderive::scene_inheritance::Editor_Node<Renderable_Editor, Scene_Base::Renderable_Editor> {
class Renderable_Editor : public Scene_Base::Renderable_Editor::next_Editor<Renderable_Editor> {
public:
template <class Next>
using next_Editor =
renderive::scene_inheritance::Editor_Node<Next, Renderable_Editor>;
private:
explicit Renderable_Editor(Scene_3D_Base& scene) : renderive::scene_inheritance::Editor_Node<
Renderable_Editor, Scene_Base::Renderable_Editor>(scene) {}
explicit Renderable_Editor(Scene_3D_Base& scene) : Scene_Base::Renderable_Editor::next_Editor<
Renderable_Editor>(scene) {}
friend class Scene_3D_Base;
};
class Attach_Builder : public renderive::scene_inheritance::Builder_Node<Attach_Builder, Scene_Base::Attach_Builder> {
class Attach_Builder : public Scene_Base::Attach_Builder::next_Builder<Attach_Builder> {
public:
template <class Next>
using next_Builder =
renderive::scene_inheritance::Builder_Node<Next, Attach_Builder>;
private:
explicit Attach_Builder(Scene_3D_Base& scene) : renderive::scene_inheritance::Builder_Node<
Attach_Builder, Scene_Base::Attach_Builder>(scene) {}
explicit Attach_Builder(Scene_3D_Base& scene) : Scene_Base::Attach_Builder::next_Builder<
Attach_Builder>(scene) {}
friend class Scene_3D_Base;
};
using Renderable_Edit = std::function<void(Renderable_Editor&)>;
[[nodiscard]] Edit_Operation edit_renderables(Renderable_Edit edit);
struct Observer
: renderive::scene_inheritance::Observer_Node<
Scene_3D_Base, Scene_Base::Observer> {};
: Scene_Base::next_Observer<Observer> {};
protected:
Scene_3D_Base();
explicit Scene_3D_Base(std::pmr::memory_resource& memory_resource);
struct Builder_Layer
: renderive::scene_inheritance::Builder_Node<
Builder_Layer, Scene_Base::Builder_Layer> {};
struct State_Layer
: renderive::scene_inheritance::State_Node<
State_Layer, Scene_Base::State_Layer> {};
struct Builder : Scene_Base::next_Builder<Builder> {};
struct State : Scene_Base::next_State<State> {};
struct Impl;
template <class Next>
using next_Builder =
renderive::scene_inheritance::Builder_Node<Next, Builder>;
template <class Next>
using next_State =
renderive::scene_inheritance::State_Node<Next, State>;
template <class Next>
using next_Impl =
renderive::scene_inheritance::Impl_Node<Next, Impl>;
template <class Next>
using next_Observer =
renderive::scene_inheritance::Observer_Node<Next, Observer>;
template <class Next>
using next_Editor =
renderive::scene_inheritance::Editor_Node<Next, Renderable_Editor>;
static_assert(renderive::inheritance::Defines_Chain_Layer<
Builder, Scene_Base::next_Builder<Builder>,
next_Builder<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Builder_Node<
renderive::inheritance::Chain_Probe, Builder>>);
static_assert(renderive::inheritance::Defines_Chain_Layer<
State, Scene_Base::next_State<State>,
next_State<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::State_Node<
renderive::inheritance::Chain_Probe, State>>);
static_assert(renderive::inheritance::Defines_Chain_Layer<
Observer, Scene_Base::next_Observer<Observer>,
next_Observer<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Observer_Node<
renderive::inheritance::Chain_Probe, Observer>>);
static_assert(renderive::inheritance::Defines_Chain_Layer<
Renderable_Editor,
Scene_Base::Renderable_Editor::next_Editor<Renderable_Editor>,
next_Editor<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Editor_Node<
renderive::inheritance::Chain_Probe, Renderable_Editor>>);
static_assert(renderive::inheritance::Defines_Chain_Layer<
Attach_Builder,
Scene_Base::Attach_Builder::next_Builder<Attach_Builder>,
Attach_Builder::next_Builder<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Builder_Node<
renderive::inheritance::Chain_Probe, Attach_Builder>>);
Scene_3D_Base(std::pmr::memory_resource& memory_resource,
std::unique_ptr<Scene_Base::Impl> impl);
};
#include "Scene_Base.inl"
Kernel/src/renderive/scene/base/Scene_Base.inl
+13 -4
View File
@@ -177,9 +177,14 @@ public:
};
struct Scene_2D_Base::Impl
: renderive::scene_inheritance::Impl_Node<Impl, Scene_Base::Impl>,
: Scene_Base::next_Impl<Impl>,
Scene_Base::Impl::Composition_Relationships {
using Observer = Scene_2D_Base::Observer;
static_assert(renderive::inheritance::Defines_Chain_Layer<
Impl, Scene_Base::next_Impl<Impl>,
Scene_2D_Base::next_Impl<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Impl_Node<
renderive::inheritance::Chain_Probe, Impl>>);
explicit Impl(std::pmr::memory_resource& memory_resource);
void with_initial_display_edit(std::function<void()> edit);
@@ -203,10 +208,14 @@ struct Scene_2D_Base::Impl
};
struct Scene_3D_Base::Impl
: renderive::scene_inheritance::Impl_Node<Impl, Scene_Base::Impl> {
: Scene_Base::next_Impl<Impl> {
using Observer = Scene_3D_Base::Observer;
static_assert(renderive::inheritance::Defines_Chain_Layer<
Impl, Scene_Base::next_Impl<Impl>,
Scene_3D_Base::next_Impl<renderive::inheritance::Chain_Probe>,
renderive::scene_inheritance::Impl_Node<
renderive::inheritance::Chain_Probe, Impl>>);
explicit Impl(std::pmr::memory_resource& memory_resource)
: renderive::scene_inheritance::Impl_Node<
Impl, Scene_Base::Impl>(memory_resource) {}
: Scene_Base::next_Impl<Impl>(memory_resource) {}
};