107 lines
3.9 KiB
Rust
107 lines
3.9 KiB
Rust
use std::cell::RefCell;
|
|
use std::rc::Rc;
|
|
use std::str::FromStr;
|
|
use std::sync::{Arc, RwLock};
|
|
use raidillon_platform::{Platform, PlatformContext};
|
|
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 winit::event::{Event, WindowEvent};
|
|
use raidillon_assets::{ModelManager, ModelManagerRef};
|
|
use raidillon_core::Engine;
|
|
use crate::{GliumAssetManager};
|
|
use crate::render::BasicMeshRenderingSystem;
|
|
|
|
pub const MESH_RENDERER: &str = "mesh_renderer";
|
|
|
|
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 mut rendering_system_manager = RenderingSystemManager::new();
|
|
|
|
// Install rendering systems
|
|
rendering_system_manager.add_system(
|
|
MESH_RENDERER,
|
|
Box::new(BasicMeshRenderingSystem::initialize(&display))
|
|
);
|
|
|
|
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);
|
|
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_and_depth((0.1, 0.1, 0.15, 1.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 => {
|
|
let ctx = PlatformContext {
|
|
current_event: event.clone(),
|
|
asset_manager: self.asset_manager.clone(),
|
|
frame_width: w as f32,
|
|
frame_height: h as f32,
|
|
};
|
|
self.engine.update(ctx);
|
|
self.window.request_redraw();
|
|
}
|
|
_ => {},
|
|
}
|
|
});
|
|
}
|
|
}
|