Skip to content

Commit 90caa32

Browse files
ArthapzArthapz
committed
dev
1 parent 56209ff commit 90caa32

30 files changed

+1712
-938
lines changed

‎game/lua/boot.lua‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,4 +14,9 @@ end
1414

1515
local player = make_player()
1616

17-
log.info("Player created with id {}", player)
17+
local test = world:make_entity()
18+
world:add_component(test, stormkit.transform_component.new())
19+
20+
local transform = world:get_component(player, "TransformComponent")
21+
22+
log.info("Player created with id {} {}", player, transform.position)

‎game/src/main.cpp‎

Lines changed: 4 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -17,10 +17,6 @@ namespace stdfs = std::filesystem;
1717
static constexpr auto LUA_DIR = "../share/lua";
1818
#endif
1919

20-
namespace {
21-
const auto BOOT_LUA = stdfs::path { LUA_DIR } / "boot.lua";
22-
} // namespace
23-
2420
////////////////////////////////////////
2521
////////////////////////////////////////
2622
auto main(std::span<const std::string_view> args) -> int {
@@ -29,15 +25,13 @@ auto main(std::span<const std::string_view> args) -> int {
2925

3026
auto logger_singleton = log::Logger::create_logger_instance<log::ConsoleLogger>();
3127

32-
auto application = TryAssert(engine::Application::create("Game", { 800, 600 }, "Game"), "Failed to initialize Game");
33-
auto render_pipeline = TryAssert(engine::BidimPipeline::create(application, application.window().extent().to<f32>()),
28+
auto application = TryAssert(engine::Application::create("Game", LUA_DIR, { 800, 600 }, "Game"), "Failed to initialize Game");
29+
auto render_pipeline = TryAssert(engine::Pipeline2D::create(application, application.window().extent().to<f32>()),
3430
"Failed to create 2D render pipeline");
35-
application.set_frame_builder(bind_front(&engine::BidimPipeline::update_framegraph,
36-
&render_pipeline,
37-
std::ref(application.renderer())));
31+
application.set_frame_builder(bind_front(&engine::Pipeline2D::update_framegraph, &render_pipeline, as_ref(application)));
3832
render_pipeline.init_ecs(application);
3933

40-
application.run(BOOT_LUA);
34+
application.run();
4135

4236
return EXIT_SUCCESS;
4337
}

‎modules/stormkit/engine.cppm‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,4 +7,4 @@ export module stormkit.engine;
77
export import :core;
88
export import :renderer;
99
export import :ecs;
10-
export import :sprite_renderer;
10+
export import :pipeline_2d;

‎modules/stormkit/engine/2d/ecs/sprite_render_system.cppm‎

Lines changed: 161 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,161 @@
1+
// Copyright (C) 2024 Arthur LAURENT <arthur.laurent4@gmail.com>
2+
// This file is subject to the license terms in the LICENSE file
3+
// found in the top-level of this distribution
4+
5+
module;
6+
7+
#include <stormkit/core/platform_macro.hpp>
8+
#include <stormkit/core/try_expected.hpp>
9+
10+
#include <stormkit/engine/api.hpp>
11+
12+
export module stormkit.engine:ecs.sprite_render_system;
13+
14+
import std;
15+
16+
import stormkit;
17+
18+
import :core;
19+
import :dirty;
20+
21+
export namespace stormkit::engine::pipeline_2d {
22+
struct TransformComponent {
23+
math::fvec2 position = { 0.f, 0.f };
24+
math::fvec2 scale = { 0.f, 0.f };
25+
math::fvec2 rotate = { 0.f, 0.f };
26+
27+
static constexpr auto component_name() noexcept -> std::string_view { return "TransformComponent"; }
28+
29+
static constexpr auto type() noexcept -> entities::ComponentType { return hash(component_name()); }
30+
};
31+
32+
struct StaticSpriteComponent {
33+
TextureID texture_id = INVALID_TEXTURE_ID;
34+
35+
math::fbounding_rect texture_bounds = {};
36+
37+
static constexpr auto component_name() noexcept -> std::string_view { return "StaticSpriteComponent"; }
38+
39+
static constexpr auto type() noexcept -> entities::ComponentType { return hash(component_name()); }
40+
};
41+
42+
class STORMKIT_ENGINE_API SpriteRenderSystem {
43+
struct PrivateTag {};
44+
45+
public:
46+
struct Sprite {
47+
entities::Entity e;
48+
gpu::ImageView texture;
49+
gpu::Sampler sampler;
50+
};
51+
52+
SpriteRenderSystem(PrivateTag) noexcept;
53+
~SpriteRenderSystem() noexcept;
54+
55+
SpriteRenderSystem(const SpriteRenderSystem&) = delete;
56+
auto operator=(const SpriteRenderSystem&) -> SpriteRenderSystem& = delete;
57+
58+
SpriteRenderSystem(SpriteRenderSystem&&) noexcept;
59+
auto operator=(SpriteRenderSystem&&) noexcept -> SpriteRenderSystem&;
60+
61+
static auto create(const Renderer& renderer,
62+
const gpu::RasterPipelineState& initial_state,
63+
const gpu::DescriptorSetLayout& camera_descriptor_set) noexcept -> gpu::Expected<SpriteRenderSystem>;
64+
65+
auto update(entities::EntityManager& world, fsecond delta, const entities::Entities&) noexcept -> void;
66+
67+
auto on_message_received(const Renderer& renderer,
68+
entities::EntityManager& world,
69+
const entities::Message& message,
70+
const entities::Entities& entities) noexcept -> void;
71+
72+
auto insert_tasks(const Application& application,
73+
FrameBuilder& graph,
74+
FrameBuilder::ResourceID backbuffer_id,
75+
FrameBuilder::ResourceID camera_buffer_id,
76+
const gpu::DescriptorSet& camera_descriptor_set,
77+
u32 camera_current_offset) noexcept -> void;
78+
79+
auto sprites() const noexcept -> const std::vector<Sprite>&;
80+
81+
private:
82+
auto do_init(const Renderer&, const gpu::RasterPipelineState&, const gpu::DescriptorSetLayout&) noexcept
83+
-> gpu::Expected<void>;
84+
85+
auto update_task(const Application&, FrameBuilder&, FrameBuilder::ResourceID) noexcept -> void;
86+
auto render_static_sprite_task(FrameBuilder&,
87+
FrameBuilder::ResourceID,
88+
FrameBuilder::ResourceID,
89+
FrameBuilder::ResourceID,
90+
const gpu::DescriptorSet&,
91+
u32) noexcept -> void;
92+
93+
struct {
94+
DeferInit<gpu::Shader> vertex_shader;
95+
DeferInit<gpu::Shader> fragment_shader;
96+
97+
DeferInit<gpu::DescriptorSetLayout> descriptor_layout;
98+
DeferInit<gpu::DescriptorSet> descriptor_set;
99+
100+
DeferInit<gpu::PipelineLayout> pipeline_layout;
101+
DeferInit<gpu::Pipeline> pipeline;
102+
} m_static_sprite_data;
103+
104+
struct {
105+
DeferInit<gpu::DescriptorPool> descriptor_pool;
106+
107+
DeferInit<gpu::Buffer> buffer;
108+
u32 current_offset = 0;
109+
} m_sprite_data;
110+
111+
using Sprites = Dirtyable<std::vector<Sprite>>;
112+
113+
Sprites m_sprites = Sprites::create_dirty();
114+
};
115+
} // namespace stormkit::engine::pipeline_2d
116+
117+
/////////////////////////////////////////////////////////////////////
118+
/// IMPLEMENTATION ///
119+
/////////////////////////////////////////////////////////////////////
120+
121+
namespace stormkit::engine::pipeline_2d {
122+
//////////////////////////////////////
123+
//////////////////////////////////////
124+
STORMKIT_FORCE_INLINE
125+
inline SpriteRenderSystem::SpriteRenderSystem(PrivateTag) noexcept
126+
: m_sprites { Dirtyable<std::vector<Sprite>>::create_dirty() } {
127+
}
128+
129+
//////////////////////////////////////
130+
//////////////////////////////////////
131+
STORMKIT_FORCE_INLINE
132+
inline SpriteRenderSystem::~SpriteRenderSystem() noexcept = default;
133+
134+
//////////////////////////////////////
135+
//////////////////////////////////////
136+
STORMKIT_FORCE_INLINE
137+
inline SpriteRenderSystem::SpriteRenderSystem(SpriteRenderSystem&& other) noexcept = default;
138+
139+
//////////////////////////////////////
140+
//////////////////////////////////////
141+
STORMKIT_FORCE_INLINE
142+
inline auto SpriteRenderSystem::operator=(SpriteRenderSystem&& other) noexcept -> SpriteRenderSystem& = default;
143+
//////////////////////////////////////
144+
//////////////////////////////////////
145+
STORMKIT_FORCE_INLINE
146+
inline auto SpriteRenderSystem::sprites() const noexcept -> const std::vector<Sprite>& {
147+
return m_sprites.read();
148+
}
149+
150+
//////////////////////////////////////
151+
//////////////////////////////////////
152+
STORMKIT_FORCE_INLINE
153+
inline auto SpriteRenderSystem::create(const Renderer& renderer,
154+
const gpu::RasterPipelineState& initial_state,
155+
const gpu::DescriptorSetLayout& camera_descriptor_set) noexcept
156+
-> gpu::Expected<SpriteRenderSystem> {
157+
auto out = SpriteRenderSystem { PrivateTag {} };
158+
Try(out.do_init(renderer, initial_state, camera_descriptor_set));
159+
Return out;
160+
}
161+
} // namespace stormkit::engine::pipeline_2d

‎modules/stormkit/engine/2d/pipeline_2d.cppm‎

Lines changed: 133 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,133 @@
1+
// Copyright (C) 2024 Arthur LAURENT <arthur.laurent4@gmail.com>
2+
// This file is subject to the license terms in the LICENSE file
3+
// found in the top-level of this distribution
4+
5+
module;
6+
7+
#include <stormkit/core/platform_macro.hpp>
8+
#include <stormkit/core/try_expected.hpp>
9+
10+
#include <stormkit/engine/api.hpp>
11+
12+
export module stormkit.engine:pipeline_2d;
13+
14+
import std;
15+
16+
import stormkit;
17+
18+
import :core;
19+
import :renderer;
20+
import :dirty;
21+
import :ecs.sprite_render_system;
22+
23+
namespace stdr = std::ranges;
24+
25+
export namespace stormkit::engine {
26+
struct Camera {
27+
math::fmat4 projection = math::fmat4::identity();
28+
math::fmat4 view = math::fmat4::identity();
29+
30+
static constexpr auto layout_binding() -> gpu::DescriptorSetLayoutBinding {
31+
return { .binding = 0,
32+
.type = gpu::DescriptorType::UNIFORM_BUFFER_DYNAMIC,
33+
.stages = gpu::ShaderStageFlag::VERTEX,
34+
.descriptor_count = 1 };
35+
}
36+
};
37+
38+
class STORMKIT_ENGINE_API Pipeline2D {
39+
struct PrivateTag {};
40+
41+
public:
42+
Pipeline2D(Application& application, const math::fextent2& viewport, PrivateTag) noexcept;
43+
~Pipeline2D() noexcept;
44+
45+
Pipeline2D(const Pipeline2D&) = delete;
46+
auto operator=(const Pipeline2D&) -> Pipeline2D& = delete;
47+
48+
Pipeline2D(Pipeline2D&&) noexcept;
49+
auto operator=(Pipeline2D&&) noexcept -> Pipeline2D&;
50+
51+
[[nodiscard]]
52+
static auto create(Application& application, const math::fextent2& viewport) noexcept -> gpu::Expected<Pipeline2D>;
53+
[[nodiscard]]
54+
static auto allocate(Application& application, const math::fextent2& viewport) noexcept
55+
-> gpu::Expected<Heap<Pipeline2D>>;
56+
57+
auto init_ecs(Application& application) -> void;
58+
59+
auto update_framegraph(const Application& application, FrameBuilder& graph) noexcept -> void;
60+
61+
private:
62+
auto do_init(Application&) noexcept -> gpu::Expected<void>;
63+
64+
auto update_task(const Renderer&, FrameBuilder&, FrameBuilder::ResourceID) noexcept -> void;
65+
66+
Ref<const Locked<entities::EntityManager>> m_world;
67+
68+
struct {
69+
gpu::RasterPipelineState pipeline_state;
70+
71+
DeferInit<gpu::DescriptorPool> descriptor_pool;
72+
73+
DeferInit<gpu::DescriptorSetLayout> camera_descriptor_layout;
74+
DeferInit<gpu::DescriptorSet> camera_descriptor_set;
75+
DeferInit<gpu::Buffer> camera_buffer;
76+
u32 camera_current_offset = 0;
77+
} m_scene_data;
78+
79+
struct _ViewData {
80+
Camera camera;
81+
math::fextent2 viewport;
82+
};
83+
84+
using ViewData = Dirtyable<_ViewData>;
85+
86+
ViewData m_view;
87+
88+
Locked<DeferInit<pipeline_2d::SpriteRenderSystem>> m_sprite_render_system;
89+
};
90+
91+
inline constexpr auto PIPELINE_2D_LOGGER = log::Module { "2d pipeline" };
92+
} // namespace stormkit::engine
93+
94+
/////////////////////////////////////////////////////////////////////
95+
/// IMPLEMENTATION ///
96+
/////////////////////////////////////////////////////////////////////
97+
98+
namespace stormkit::engine {
99+
//////////////////////////////////////
100+
//////////////////////////////////////
101+
STORMKIT_FORCE_INLINE
102+
inline Pipeline2D::~Pipeline2D() noexcept = default;
103+
104+
//////////////////////////////////////
105+
//////////////////////////////////////
106+
STORMKIT_FORCE_INLINE
107+
inline Pipeline2D::Pipeline2D(Pipeline2D&&) noexcept = default;
108+
109+
//////////////////////////////////////
110+
//////////////////////////////////////
111+
STORMKIT_FORCE_INLINE
112+
inline auto Pipeline2D::operator=(Pipeline2D&&) noexcept -> Pipeline2D& = default;
113+
114+
//////////////////////////////////////
115+
//////////////////////////////////////
116+
STORMKIT_FORCE_INLINE
117+
inline auto Pipeline2D::create(Application& application, const math::fextent2& viewport) noexcept
118+
-> gpu::Expected<Pipeline2D> {
119+
auto sprite_renderer = Pipeline2D { application, viewport, PrivateTag {} };
120+
Try(sprite_renderer.do_init(application));
121+
Return sprite_renderer;
122+
}
123+
124+
//////////////////////////////////////
125+
//////////////////////////////////////
126+
STORMKIT_FORCE_INLINE
127+
inline auto Pipeline2D::allocate(Application& application, const math::fextent2& viewport) noexcept
128+
-> gpu::Expected<Heap<Pipeline2D>> {
129+
auto sprite_renderer = core::allocate_unsafe<Pipeline2D>(application, viewport, PrivateTag {});
130+
Try(sprite_renderer->do_init(application));
131+
Return sprite_renderer;
132+
}
133+
} // namespace stormkit::engine

0 commit comments

Comments
 (0)