Rename crate folders to remove raidillon prefix

glium_platform/src/platform.rs

@@ -0,0 +1,85 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::{Arc, RwLock};
+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 glium::Surface;
+use crate::system::{RenderingSystemManager, RenderingSystem, RenderingContext};
+use winit::event::{Event, WindowEvent};
+use raidillon_assets::{ModelManager, ModelManagerRef};
+use raidillon_core::Engine;
+use crate::GliumAssetManager;
+use crate::render::BasicRenderingSystem;
+
+pub struct GliumPlatform {
+    event_loop: EventLoop<()>,
+    window: Window,
+    display: Display<WindowSurface>,
+    rendering_system_manager: RenderingSystemManager,
+    asset_manager: ModelManagerRef,
+    engine: Engine,
+}
+
+impl Platform for GliumPlatform {
+    fn initialize(mut engine: Engine, title: String, width: u32, height: u32) -> Self {
+        let event_loop = glium::winit::event_loop::EventLoop::builder()
+            .build()
+            .expect("create event-loop");
+
+        let (window, display) = SimpleWindowBuilder::new()
+            .with_title(title.as_str())
+            .with_inner_size(width, height)
+            .build(&event_loop);
+
+        let asset_manager: ModelManagerRef = Rc::new(RefCell::new(Box::new(GliumAssetManager::new(Box::new(display.clone())))));
+        let rendering_system_manager = RenderingSystemManager::new();
+        engine.set_model_manager(asset_manager.clone());
+        Self {
+            event_loop,
+            window,
+            display,
+            rendering_system_manager,
+            asset_manager,
+            engine
+        }
+    }
+
+    fn run(mut self) {
+        let _ = &self.event_loop.run(move |event, el| {
+            match event {
+                Event::WindowEvent { event, .. } => match event {
+                    WindowEvent::CloseRequested => {
+                        // TODO: Run uninitialize on renderer and engine
+                        el.exit();
+                    },
+                    WindowEvent::RedrawRequested => {
+                        let mut target = self.display.draw();
+                        target.clear_color(0.0, 0.0, 0.0, 1.0);
+                        // TODO: let mut context;
+                        let mut context = RenderingContext {
+                            scene: self.engine.scene_manager.current_mut(),
+                            target: &mut target,
+                            asset_manager: self.asset_manager.clone(),
+                        };
+
+                        for (system_id, system) in self.rendering_system_manager.systems.iter_mut() {
+                            system.render(&mut context);
+                        }
+                        target.finish().unwrap();
+                    }
+                    _ => {},
+                },
+                Event::AboutToWait => {
+                    self.engine.set_winit_event(event.clone());
+                    self.engine.update();
+                    self.window.request_redraw();
+                }
+                _ => {},
+            }
+        });
+    }
+}