Implement Engine, add compile_shader to rendering systems

- Implement the initial version of the run method of the glium platform
- Add asset manager to the context of the renderer. I will probably move that to either the engine or somewhere else later.
- Other unimportant stuff that I'm too lazy to include here. Early stage commit messages don't really matter anyways.

Cargo.lock

@@ -1268,6 +1268,7 @@ dependencies = [
 name = "raidillon_platform"
 version = "0.1.0"
 dependencies = [
+ "raidillon_core",
  "winit",
 ]
 

raidillon_core/src/engine.rs

@@ -0,0 +1,6 @@
+use crate::SceneManager;
+
+pub struct Engine {
+    scene_manager: SceneManager,
+    // TODO: Systems
+}

raidillon_core/src/lib.rs

@@ -1,2 +1,5 @@
 mod scene;
-pub use scene::{Scene, SceneManager};
+mod engine;
+
+pub use scene::{Scene, SceneManager};
+pub use engine::Engine;

raidillon_glium/src/platform.rs

@@ -1,14 +1,16 @@
 use std::sync::{Arc, RwLock};
-use glium::backend::Facade;
 use raidillon_platform::Platform;
 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 crate::system::{RenderingSystemManager, RenderingSystem};
+use glium::Surface;
+use crate::system::{RenderingSystemManager, RenderingSystem, RenderingContext};
 use winit::event::{Event, WindowEvent};
+use raidillon_core::Engine;
 use crate::GliumAssetManager;
+use crate::render::BasicRenderingSystem;
 
 pub struct GliumPlatform<RS: RenderingSystem> {
     event_loop: EventLoop<()>,
@@ -29,8 +31,8 @@ impl<RS: RenderingSystem> Platform for GliumPlatform<RS> {
             .with_inner_size(width, height)
             .build(&event_loop);
 
-        let rendering_system_manager = RenderingSystemManager::new();
         let asset_manager = Arc::new(RwLock::new(GliumAssetManager::new(Box::new(display.clone()))));
+        let rendering_system_manager = RenderingSystemManager::new();
         Self {
             event_loop,
             window,
@@ -40,17 +42,24 @@ impl<RS: RenderingSystem> Platform for GliumPlatform<RS> {
         }
     }
 
-    fn run(self) {
+    fn run(mut self, engine: Engine) {
         let _ = &self.event_loop.run(move |event, el| {
             match event {
                 Event::WindowEvent { event, .. } => match event {
                     WindowEvent::CloseRequested => {},
                     WindowEvent::RedrawRequested => {
+                        let mut target = self.display.draw();
+                        target.clear_color(0.0, 0.0, 0.0, 1.0);
+                        // TODO: let mut context;
 
+                        for (system_id, system) in self.rendering_system_manager.systems.iter_mut() {
+                            todo!();
+                        }
                     }
                     _ => {},
                 },
                 Event::AboutToWait => {
+                    // TODO: Run <engine: Engine> systems here
                     self.window.request_redraw();
                 }
                 _ => {},

raidillon_glium/src/system.rs

@@ -1,16 +1,20 @@
 use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
 use raidillon_core::Scene;
 use glium::Surface;
+use crate::GliumAssetManager;
 
 pub struct RenderingContext<'a, S: Surface> {
     pub scene: &'a mut Scene,
     pub target: &'a mut S,
+    pub asset_manager: Arc<RwLock<GliumAssetManager>>,
 }
 
 /// The internal "rendering system" trait of raidillon_glium.
 /// This is unrelated to the main System trait in raidillon_core.
 pub trait RenderingSystem {
     fn render<S: Surface>(ctx: &mut RenderingContext<S>);
+    fn compile_shaders() {}
 }
 
 type SystemID = String;

raidillon_platform/Cargo.toml

@@ -5,3 +5,4 @@ edition = "2024"
 
 [dependencies]
 winit = "0.30.12"
+raidillon_core = { path = "../raidillon_core" }

raidillon_platform/src/platform.rs

@@ -1,5 +1,7 @@
+use raidillon_core::Engine;
+
 pub trait Platform {
     /// Initialize platform.
     fn initialize(title: String, width: u32, height: u32) -> Self;
-    fn run(self);
+    fn run(self, engine: Engine);
 }