reo/raidillon
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor system registration to use TypeIds

Browse source
This commit is contained in:
Emre Osmanoğlu 2025-09-10 13:21:35 +03:00
parent 0c0d5cdb2a
commit 75fd59a504
5 changed files with 68 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

10
engine/src/engine.rs
View file

@ -1,12 +1,10 @@
use std::cell::RefCell;
use std::rc::Rc;
use winit::event::Event;
use raidillon_core::scene::{Scene, SceneManager};
use crate::system::{SystemContext, SystemManager};
use raidillon_assets::{ModelManager, ModelManagerRef};
use raidillon_core::context::PlatformContext;
use raidillon_core::DebugUIBuffer;
use raidillon_core::engine::{EngineTrait};
use raidillon_core::engine::EngineTrait;
pub struct Engine {
pub scene_manager: SceneManager,
@ -28,7 +26,7 @@ impl EngineTrait for Engine {
/// Initialize systems, load the world.
fn initialize(&mut self, platform_context: PlatformContext) {
// Engine Loading Stage 1: initialize systems
for (system_id, system) in self.system_manager.systems.iter_mut() {
for system in self.system_manager.systems.values_mut() {
system.initialize();
}
@ -39,7 +37,7 @@ impl EngineTrait for Engine {
};
// Engine Loading Stage 2: load world
for (system_id, system) in self.system_manager.systems.iter_mut() {
for system in self.system_manager.systems.values_mut() {
system.load_world(&mut ctx);
}
}
@ -53,7 +51,7 @@ impl EngineTrait for Engine {
debug_ui_buffer: self.debug_ui_buffer.clone(),
};
for (system_id, system) in self.system_manager.systems.iter_mut() {
for system in self.system_manager.systems.values_mut() {
system.update(&mut ctx);
}
}

25
engine/src/system.rs
View file

@ -1,9 +1,9 @@
use std::any::TypeId;
use std::cell::RefCell;
use std::rc::Rc;
use raidillon_core::scene::Scene;
use indexmap::IndexMap;
use winit::event::Event;
use raidillon_core::context::PlatformContext;
use raidillon_core::scene::Scene;
use raidillon_core::DebugUIBuffer;
pub struct SystemContext<'a> {
@ -17,26 +17,27 @@ pub trait System {
/// Initialize the system.
fn initialize(&mut self) {}
/// Spawn the first entities of the world.
fn load_world(&mut self, ctx: &mut SystemContext) {}
fn update(&mut self, ctx: &mut SystemContext) {}
fn load_world(&mut self, _ctx: &mut SystemContext) {}
fn update(&mut self, _ctx: &mut SystemContext) {}
}
pub type SystemID = &'static str;
pub struct SystemManager {
pub systems: IndexMap<SystemID, Box<dyn System>>,
pub systems: IndexMap<TypeId, Box<dyn System>>,
}
impl SystemManager {
pub fn new() -> Self {
let systems = IndexMap::default();
Self { systems }
Self {
systems: IndexMap::default(),
}
}
pub fn add_system(&mut self, id: SystemID, system: Box<dyn System>) {
self.systems.insert(id, system);
pub fn add<S: System + Default + 'static>(&mut self) {
self.systems
.insert(TypeId::of::<S>(), Box::new(S::default()));
}
pub fn remove_system(&mut self, id: SystemID) {
self.systems.shift_remove(&id);
pub fn remove<S: 'static>(&mut self) {
self.systems.shift_remove(&TypeId::of::<S>());
}
}

27
game/src/main.rs
View file

@ -1,4 +1,3 @@
use std::path::Path;
use glam::{Quat, Vec3};
use raidillon_engine::{Engine, system::System};
use raidillon_engine::system::SystemContext;
@ -10,30 +9,31 @@ use raidillon_ecs::Transform;
use raidillon_core::scene::Scene;
#[cfg(feature = "glium")]
use raidillon_glium::GliumPlatform;
use raidillon_core::DebugUIBuffer;
use winit::event::{Event, WindowEvent};
const TEST_GLTF: &str = "pink-monkey.gltf";
const RENDERING_TEST_SYSTEM: &str = "rendering_test_system";
const UPDATE_ASPECT_RATIO_SYSTEM: &str = "update_aspect_ratio_system";
const MAIN_SCENE_ID: &str = "main_scene";
#[derive(Default)]
struct UpdateAspectRatioSystem;
impl System for UpdateAspectRatioSystem {
fn initialize(&mut self) {}
fn load_world(&mut self, ctx: &mut SystemContext) {}
fn load_world(&mut self, _ctx: &mut SystemContext) {}
fn update(&mut self, ctx: &mut SystemContext) {
// FIXME: Need an event handler rework for systems.
match &ctx.platform_context.current_event {
Event::WindowEvent { event, .. } => match event {
WindowEvent::Resized(sz) => {
let _ = ctx.scene.world.query_mut::<&mut Camera>().into_iter().map(|mut cam| {
cam.1.aspect = sz.width as f32 / sz.height as f32;
let _ = ctx
.scene
.world
.query_mut::<&mut Camera>()
.into_iter()
.map(|(_, cam)| {
cam.aspect = sz.width as f32 / sz.height as f32;
});
}
_ => {}
@ -43,6 +43,7 @@ impl System for UpdateAspectRatioSystem {
}
}
#[derive(Default)]
struct RenderingTestSystem;
impl System for RenderingTestSystem {
fn initialize(&mut self) {}
@ -82,10 +83,8 @@ impl System for RenderingTestSystem {
fn main() {
let mut engine = Engine::new();
// Define systems
// engine.system_manager.add_system("spawn_chunks".to_string(), ChunkSystem);
// engine.system_manager.add_system("movement".to_string(), MovementSystem);
engine.system_manager.add_system(RENDERING_TEST_SYSTEM, Box::new(RenderingTestSystem));
engine.system_manager.add_system(UPDATE_ASPECT_RATIO_SYSTEM, Box::new(UpdateAspectRatioSystem));
engine.system_manager.add::<RenderingTestSystem>();
engine.system_manager.add::<UpdateAspectRatioSystem>();
// Set up the scene
let main_scene = Scene::new(
@ -97,7 +96,7 @@ fn main() {
#[cfg(feature = "glium")]
{
let mut platform = GliumPlatform::initialize(
let platform = GliumPlatform::initialize(
engine,
"Raidillon".to_string(),
1920,

41
glium_platform/src/platform.rs
View file

@ -1,25 +1,19 @@
use std::cell::RefCell;
use std::rc::Rc;
use std::str::FromStr;
use std::sync::{Arc, RwLock};
use raidillon_platform::{Platform, PlatformContext};
use glium::backend::glutin::Display;
use glium::backend::glutin::SimpleWindowBuilder;
use glium::glutin::surface::WindowSurface;
use glium::winit::event_loop::EventLoop;
use glium::winit::window::Window;
use glium::backend::glutin::Display;
use glium::glutin::surface::WindowSurface;
use glium::backend::glutin::SimpleWindowBuilder;
use glium::Surface;
use crate::system::{RenderingSystemManager, RenderingSystem, RenderingContext, SystemID};
use crate::system::{RenderingContext, RenderingSystemManager};
use winit::event::{Event, WindowEvent};
use raidillon_assets::{ModelManager, ModelManagerRef};
use raidillon_assets::ModelManagerRef;
use raidillon_core::engine::EngineTrait;
use raidillon_engine::Engine;
use crate::{GliumAssetManager};
use crate::render::debug_ui::ImguiBridge;
use crate::render::BasicMeshRenderingSystem;
pub const MESH_RENDERER: &str = "mesh_renderer";
pub const DEBUG_UI_RENDERER: &str = "debug_ui_renderer";
use crate::GliumAssetManager;
pub struct GliumPlatform<E: EngineTrait> {
event_loop: EventLoop<()>,
@ -45,15 +39,8 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
let mut rendering_system_manager = RenderingSystemManager::new();
// Install rendering systems
rendering_system_manager.add_system(
MESH_RENDERER,
Box::new(BasicMeshRenderingSystem::initialize(&display, &window))
);
rendering_system_manager.add_system(
DEBUG_UI_RENDERER,
Box::new(ImguiBridge::initialize(&display, &window)),
);
rendering_system_manager.add::<BasicMeshRenderingSystem>(&display, &window);
rendering_system_manager.add::<ImguiBridge>(&display, &window);
Self {
event_loop,
@ -77,8 +64,8 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
let _ = &self.event_loop.run(move |event, el| {
self.rendering_system_manager
.systems
.iter_mut()
.for_each(|(_, system)| system.handle_event(&mut self.window, event.clone()));
.values_mut()
.for_each(|system| system.handle_event(&mut self.window, event.clone()));
match event {
Event::WindowEvent { event, .. } => match event {
@ -100,8 +87,8 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
self.rendering_system_manager
.systems
.iter_mut()
.for_each(|(_, system)| system.render(&mut context));
.values_mut()
.for_each(|system| system.render(&mut context));
target.finish().unwrap();
}
_ => {},
@ -112,8 +99,8 @@ impl<E: EngineTrait> Platform<E> for GliumPlatform<E> {
self.engine.update(ctx2);
self.rendering_system_manager
.systems
.iter_mut()
.for_each(|(_, system)| system.prepare_frame(&mut self.window));
.values_mut()
.for_each(|system| system.prepare_frame(&mut self.window));
self.window.request_redraw();
}
_ => {},

36
glium_platform/src/system.rs
View file

@ -1,12 +1,12 @@
use std::any::TypeId;
use std::cell::RefCell;
use std::rc::Rc;
use raidillon_core::scene::Scene;
use indexmap::IndexMap;
use glium::{Display, Frame};
use glium::glutin::surface::WindowSurface;
use indexmap::IndexMap;
use raidillon_assets::ModelManagerRef;
use raidillon_core::DebugUIBuffer;
use crate::GliumAssetManager;
use raidillon_core::scene::Scene;
pub struct RenderingContext<'a> {
pub scene: &'a Scene,
@ -19,16 +19,21 @@ pub struct RenderingContext<'a> {
/// The internal "rendering system" trait of glium_platform.
/// This is unrelated to the main System trait in core.
pub trait RenderingSystem {
fn handle_event(&mut self, window: &mut glium::winit::window::Window, event: winit::event::Event<()>) {}
fn prepare_frame(&mut self, window: &mut glium::winit::window::Window) {}
fn handle_event(
&mut self,
_window: &mut glium::winit::window::Window,
_event: winit::event::Event<()>,
) {
}
fn prepare_frame(&mut self, _window: &mut glium::winit::window::Window) {}
fn render(&mut self, ctx: &mut RenderingContext);
fn initialize(display: &Display<WindowSurface>, window: &glium::winit::window::Window) -> Self where Self: Sized;
fn initialize(display: &Display<WindowSurface>, window: &glium::winit::window::Window) -> Self
where
Self: Sized;
}
pub type SystemID = &'static str;
pub struct RenderingSystemManager {
pub systems: IndexMap<SystemID, Box<dyn RenderingSystem>>,
pub systems: IndexMap<TypeId, Box<dyn RenderingSystem>>,
}
impl RenderingSystemManager {
@ -37,11 +42,16 @@ impl RenderingSystemManager {
systems: IndexMap::default(),
}
}
pub fn add_system(&mut self, id: SystemID, system: Box<dyn RenderingSystem>) {
self.systems.insert(id, system);
pub fn add<R>(&mut self, display: &Display<WindowSurface>, window: &glium::winit::window::Window)
where
R: RenderingSystem + 'static,
{
let system = R::initialize(display, window);
self.systems.insert(TypeId::of::<R>(), Box::new(system));
}
pub fn remove_system(&mut self, id: SystemID) {
self.systems.shift_remove(&id);
pub fn remove<R: 'static>(&mut self) {
self.systems.shift_remove(&TypeId::of::<R>());
}
}