114 lines
4.4 KiB
Rust
114 lines
4.4 KiB
Rust
use std::cell::RefCell;
|
|
use std::rc::Rc;
|
|
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::Surface;
|
|
use crate::system::{RenderingContext, RenderingSystemManager};
|
|
use winit::event::{Event, WindowEvent};
|
|
use raidillon_assets::ModelManagerRef;
|
|
use raidillon_core::engine::EngineTrait;
|
|
use crate::render::debug_ui::ImguiBridge;
|
|
use crate::render::BasicMeshRenderingSystem;
|
|
use crate::GliumAssetManager;
|
|
|
|
pub struct GliumPlatform<E: EngineTrait<PlatformCtx = PlatformContext>> {
|
|
event_loop: EventLoop<()>,
|
|
window: Window,
|
|
display: Display<WindowSurface>,
|
|
rendering_system_manager: RenderingSystemManager,
|
|
asset_manager: ModelManagerRef,
|
|
engine: E,
|
|
}
|
|
|
|
impl<E: EngineTrait<PlatformCtx = PlatformContext>> Platform<E> for GliumPlatform<E> {
|
|
fn initialize(mut engine: E, 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 mut rendering_system_manager = RenderingSystemManager::new();
|
|
|
|
// Install rendering systems
|
|
rendering_system_manager.add::<BasicMeshRenderingSystem>(&display, &window);
|
|
rendering_system_manager.add::<ImguiBridge>(&display, &window);
|
|
|
|
Self {
|
|
event_loop,
|
|
window,
|
|
display,
|
|
rendering_system_manager,
|
|
asset_manager,
|
|
engine,
|
|
}
|
|
}
|
|
|
|
fn run(mut self) {
|
|
let (w, h): (u32, u32) = self.window.inner_size().into();
|
|
let ctx = PlatformContext {
|
|
current_event: Event::AboutToWait,
|
|
asset_manager: self.asset_manager.clone(),
|
|
frame_width: w as f32,
|
|
frame_height: h as f32,
|
|
};
|
|
self.engine.initialize(ctx.clone());
|
|
let _ = &self.event_loop.run(move |event, el| {
|
|
self.rendering_system_manager
|
|
.systems
|
|
.values_mut()
|
|
.for_each(|system| system.handle_event(&mut self.window, event.clone()));
|
|
|
|
let mut ctx2 = ctx.clone();
|
|
ctx2.current_event = event.clone();
|
|
self.engine.handle_event(ctx2);
|
|
|
|
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_and_depth((0.1, 0.1, 0.15, 1.0), 1.0);
|
|
let (scene_mut, debug_ui_buffer) = self.engine.scene_and_debug_ui_buffer_mut();
|
|
let mut context = RenderingContext {
|
|
scene: scene_mut,
|
|
target: &mut target,
|
|
asset_manager: self.asset_manager.clone(),
|
|
window: &mut self.window,
|
|
debug_ui_buffer,
|
|
};
|
|
|
|
self.rendering_system_manager
|
|
.systems
|
|
.values_mut()
|
|
.for_each(|system| system.render(&mut context));
|
|
target.finish().unwrap();
|
|
}
|
|
_ => {},
|
|
},
|
|
Event::AboutToWait => {
|
|
let mut ctx2 = ctx.clone();
|
|
ctx2.current_event = event.clone();
|
|
self.engine.update(ctx2);
|
|
self.rendering_system_manager
|
|
.systems
|
|
.values_mut()
|
|
.for_each(|system| system.prepare_frame(&mut self.window));
|
|
self.window.request_redraw();
|
|
}
|
|
_ => {},
|
|
}
|
|
});
|
|
}
|
|
}
|