mirror of https://github.com/AxioDL/metaforce.git
592 lines
20 KiB
Rust
592 lines
20 KiB
Rust
#![allow(dead_code)]
|
|
#![allow(unused_imports)]
|
|
#![allow(unused_variables)]
|
|
#![allow(unused_unsafe)]
|
|
|
|
use std::{collections::HashMap, time::Instant};
|
|
|
|
use sdl2::{
|
|
controller::{Axis, Button, GameController},
|
|
event::Event as SDLEvent,
|
|
GameControllerSubsystem, Sdl,
|
|
};
|
|
use wgpu::Backend;
|
|
use winit::{
|
|
event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
|
|
event_loop::ControlFlow,
|
|
};
|
|
|
|
use crate::{
|
|
ffi::{SpecialKey, WindowSize},
|
|
gpu::{create_depth_texture, create_render_texture, initialize_gpu, DeviceHolder},
|
|
imgui::{initialize_imgui, ImGuiState},
|
|
shaders::render_into_pass,
|
|
};
|
|
|
|
mod gpu;
|
|
mod imgui;
|
|
mod imgui_backend;
|
|
mod shaders;
|
|
mod util;
|
|
mod zeus;
|
|
|
|
#[cxx::bridge(namespace = "aurora")]
|
|
mod ffi {
|
|
unsafe extern "C++" {
|
|
include!("aurora.hpp");
|
|
pub(crate) type AppDelegate;
|
|
}
|
|
|
|
unsafe extern "C++" {
|
|
include!("lib.hpp");
|
|
pub(crate) fn App_onAppLaunched(cb: Pin<&mut AppDelegate>);
|
|
pub(crate) fn App_onAppIdle(cb: Pin<&mut AppDelegate>, dt: f32) -> bool;
|
|
pub(crate) fn App_onAppDraw(cb: Pin<&mut AppDelegate>);
|
|
pub(crate) fn App_onAppPostDraw(cb: Pin<&mut AppDelegate>);
|
|
pub(crate) fn App_onAppWindowResized(cb: Pin<&mut AppDelegate>, size: &WindowSize);
|
|
pub(crate) fn App_onAppWindowMoved(cb: Pin<&mut AppDelegate>, x: i32, y: i32);
|
|
pub(crate) fn App_onAppExiting(cb: Pin<&mut AppDelegate>);
|
|
// Input
|
|
pub(crate) fn App_onCharKeyDown(cb: Pin<&mut AppDelegate>, code: u8, is_repeat: bool);
|
|
pub(crate) fn App_onCharKeyUp(cb: Pin<&mut AppDelegate>, code: u8);
|
|
pub(crate) fn App_onSpecialKeyDown(
|
|
cb: Pin<&mut AppDelegate>,
|
|
key: SpecialKey,
|
|
is_repeat: bool,
|
|
);
|
|
pub(crate) fn App_onSpecialKeyUp(cb: Pin<&mut AppDelegate>, key: SpecialKey);
|
|
// Controller
|
|
pub(crate) fn App_onControllerButton(
|
|
cb: Pin<&mut AppDelegate>,
|
|
idx: u32,
|
|
button: ControllerButton,
|
|
pressed: bool,
|
|
);
|
|
pub(crate) fn App_onControllerAxis(
|
|
cb: Pin<&mut AppDelegate>,
|
|
idx: u32,
|
|
axis: ControllerAxis,
|
|
value: i16,
|
|
);
|
|
}
|
|
|
|
pub struct Window {
|
|
pub(crate) inner: Box<WindowContext>,
|
|
}
|
|
|
|
pub struct WindowSize {
|
|
pub width: u32,
|
|
pub height: u32,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum Backend {
|
|
Invalid,
|
|
Vulkan,
|
|
Metal,
|
|
D3D12,
|
|
D3D11,
|
|
OpenGL,
|
|
WebGPU,
|
|
}
|
|
|
|
pub enum ElementState {
|
|
Pressed,
|
|
Released,
|
|
}
|
|
|
|
pub enum MouseButton {
|
|
Left,
|
|
Right,
|
|
Middle,
|
|
Other,
|
|
}
|
|
|
|
pub enum SpecialKey {
|
|
None = 0,
|
|
F1 = 1,
|
|
F2 = 2,
|
|
F3 = 3,
|
|
F4 = 4,
|
|
F5 = 5,
|
|
F6 = 6,
|
|
F7 = 7,
|
|
F8 = 8,
|
|
F9 = 9,
|
|
F10 = 10,
|
|
F11 = 11,
|
|
F12 = 12,
|
|
Esc = 13,
|
|
Enter = 14,
|
|
Backspace = 15,
|
|
Insert = 16,
|
|
Delete = 17,
|
|
Home = 18,
|
|
End = 19,
|
|
PgUp = 20,
|
|
PgDown = 21,
|
|
Left = 22,
|
|
Right = 23,
|
|
Up = 24,
|
|
Down = 25,
|
|
Tab = 26,
|
|
}
|
|
|
|
pub struct KeyboardInput {
|
|
pub scancode: u32,
|
|
pub state: ElementState,
|
|
// pub
|
|
}
|
|
|
|
pub enum ControllerButton {
|
|
A,
|
|
B,
|
|
X,
|
|
Y,
|
|
Back,
|
|
Guide,
|
|
Start,
|
|
LeftStick,
|
|
RightStick,
|
|
LeftShoulder,
|
|
RightShoulder,
|
|
DPadUp,
|
|
DPadDown,
|
|
DPadLeft,
|
|
DPadRight,
|
|
Other,
|
|
MAX,
|
|
}
|
|
pub enum ControllerAxis {
|
|
LeftX,
|
|
LeftY,
|
|
RightX,
|
|
RightY,
|
|
TriggerLeft,
|
|
TriggerRight,
|
|
MAX,
|
|
}
|
|
pub struct Icon {
|
|
pub data: Vec<u8>,
|
|
pub width: u32,
|
|
pub height: u32,
|
|
}
|
|
|
|
extern "Rust" {
|
|
type WindowContext;
|
|
type App;
|
|
fn app_run(mut delegate: UniquePtr<AppDelegate>, icon: Icon);
|
|
fn get_args() -> Vec<String>;
|
|
fn get_window_size() -> WindowSize;
|
|
fn set_window_title(title: &CxxString);
|
|
fn get_dxt_compression_supported() -> bool;
|
|
fn get_backend() -> Backend;
|
|
fn get_backend_string() -> &'static str;
|
|
fn set_fullscreen(v: bool);
|
|
}
|
|
}
|
|
impl From<Button> for ffi::ControllerButton {
|
|
fn from(button: Button) -> Self {
|
|
match button {
|
|
Button::A => ffi::ControllerButton::A,
|
|
Button::B => ffi::ControllerButton::B,
|
|
Button::X => ffi::ControllerButton::X,
|
|
Button::Y => ffi::ControllerButton::Y,
|
|
Button::Back => ffi::ControllerButton::Back,
|
|
Button::Guide => ffi::ControllerButton::Guide,
|
|
Button::Start => ffi::ControllerButton::Start,
|
|
Button::LeftStick => ffi::ControllerButton::LeftStick,
|
|
Button::RightStick => ffi::ControllerButton::RightStick,
|
|
Button::LeftShoulder => ffi::ControllerButton::LeftShoulder,
|
|
Button::RightShoulder => ffi::ControllerButton::RightShoulder,
|
|
Button::DPadUp => ffi::ControllerButton::DPadUp,
|
|
Button::DPadDown => ffi::ControllerButton::DPadDown,
|
|
Button::DPadLeft => ffi::ControllerButton::DPadLeft,
|
|
Button::DPadRight => ffi::ControllerButton::DPadRight,
|
|
_ => ffi::ControllerButton::Other,
|
|
}
|
|
}
|
|
}
|
|
impl From<Axis> for ffi::ControllerAxis {
|
|
fn from(axis: Axis) -> Self {
|
|
match axis {
|
|
Axis::LeftX => ffi::ControllerAxis::LeftX,
|
|
Axis::LeftY => ffi::ControllerAxis::LeftY,
|
|
Axis::RightX => ffi::ControllerAxis::RightX,
|
|
Axis::RightY => ffi::ControllerAxis::RightY,
|
|
Axis::TriggerLeft => ffi::ControllerAxis::TriggerLeft,
|
|
Axis::TriggerRight => ffi::ControllerAxis::TriggerRight,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct App {
|
|
window: ffi::Window,
|
|
gpu: DeviceHolder,
|
|
imgui: ImGuiState,
|
|
// SDL
|
|
sdl: Sdl,
|
|
sdl_events: sdl2::EventPump,
|
|
sdl_controller_sys: GameControllerSubsystem,
|
|
sdl_open_controllers: HashMap<u32, GameController>,
|
|
}
|
|
|
|
pub struct WindowContext {
|
|
window: winit::window::Window,
|
|
}
|
|
|
|
static mut APP: Option<App> = None;
|
|
|
|
fn app_run(mut delegate: cxx::UniquePtr<ffi::AppDelegate>, icon: ffi::Icon) {
|
|
if delegate.is_null() {
|
|
return;
|
|
}
|
|
env_logger::init();
|
|
log::info!("Running app");
|
|
let event_loop = winit::event_loop::EventLoop::new();
|
|
let window_icon = winit::window::Icon::from_rgba(icon.data, icon.width, icon.height).expect("Failed to load icon");
|
|
let window = winit::window::WindowBuilder::new()
|
|
.with_inner_size(winit::dpi::LogicalSize::new(1280, 720))
|
|
.with_window_icon(Some(window_icon))
|
|
.build(&event_loop)
|
|
.unwrap();
|
|
let sdl = sdl2::init().unwrap();
|
|
let sdl_events = sdl.event_pump().unwrap();
|
|
let controller = sdl.game_controller().unwrap();
|
|
let gpu = initialize_gpu(&window);
|
|
let imgui = initialize_imgui(&window, &gpu);
|
|
let mut special_keys_pressed: [bool; 512] = [false; 512];
|
|
shaders::construct_state(gpu.device.clone(), gpu.queue.clone(), &gpu.config);
|
|
let app = App {
|
|
window: ffi::Window { inner: Box::new(WindowContext { window }) },
|
|
gpu,
|
|
imgui,
|
|
sdl,
|
|
sdl_events,
|
|
sdl_controller_sys: controller,
|
|
sdl_open_controllers: Default::default(),
|
|
};
|
|
unsafe {
|
|
APP.replace(app);
|
|
ffi::App_onAppLaunched(delegate.as_mut().unwrap());
|
|
};
|
|
let mut last_frame: Option<Instant> = None;
|
|
event_loop.run(move |event, _, control_flow| {
|
|
// Have the closure take ownership of the resources.
|
|
// `event_loop.run` never returns, therefore we must do this to ensure
|
|
// the resources are properly cleaned up.
|
|
let _ = &delegate;
|
|
|
|
let app = get_app();
|
|
let imgui = &mut app.imgui;
|
|
let window_ctx = get_window_context();
|
|
let gpu = &mut app.gpu;
|
|
|
|
// SDL event loop
|
|
for event in app.sdl_events.poll_iter() {
|
|
// log::info!("SDL event: {:?}", event);
|
|
match event {
|
|
SDLEvent::ControllerDeviceAdded { which, .. } => {
|
|
match app.sdl_controller_sys.open(which) {
|
|
Ok(controller) => {
|
|
log::info!("Opened SDL controller \"{}\"", controller.name());
|
|
app.sdl_open_controllers.insert(which, controller);
|
|
}
|
|
Err(err) => {
|
|
log::warn!("Failed to open SDL controller {} ({:?})", which, err);
|
|
}
|
|
}
|
|
// TODO app connected event
|
|
}
|
|
SDLEvent::ControllerDeviceRemoved { which, .. } => {
|
|
app.sdl_open_controllers.remove(&which);
|
|
// TODO app disconnected event
|
|
}
|
|
SDLEvent::ControllerButtonDown { which, button, .. } => unsafe {
|
|
ffi::App_onControllerButton(
|
|
delegate.as_mut().unwrap_unchecked(),
|
|
which,
|
|
button.into(),
|
|
true,
|
|
);
|
|
},
|
|
SDLEvent::ControllerButtonUp { which, button, .. } => unsafe {
|
|
ffi::App_onControllerButton(
|
|
delegate.as_mut().unwrap_unchecked(),
|
|
which,
|
|
button.into(),
|
|
false,
|
|
);
|
|
},
|
|
SDLEvent::ControllerAxisMotion { which, axis, value, .. } => unsafe {
|
|
ffi::App_onControllerAxis(
|
|
delegate.as_mut().unwrap_unchecked(),
|
|
which,
|
|
axis.into(),
|
|
value,
|
|
);
|
|
},
|
|
// SDL overrides exit signals
|
|
SDLEvent::Quit { .. } => {
|
|
*control_flow = ControlFlow::Exit;
|
|
return;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
// winit event loop
|
|
*control_flow = ControlFlow::Poll;
|
|
match event {
|
|
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
|
|
*control_flow = ControlFlow::Exit;
|
|
return;
|
|
}
|
|
Event::WindowEvent { event: WindowEvent::Resized(size), .. } => {
|
|
// Reconfigure the surface with the new size
|
|
app.gpu.surface_config.width = size.width;
|
|
app.gpu.surface_config.height = size.height;
|
|
app.gpu.surface.configure(&app.gpu.device, &app.gpu.surface_config);
|
|
app.gpu.depth =
|
|
create_depth_texture(&app.gpu.device, &app.gpu.surface_config, &app.gpu.config);
|
|
app.gpu.framebuffer = create_render_texture(
|
|
&app.gpu.device,
|
|
&app.gpu.surface_config,
|
|
&app.gpu.config,
|
|
);
|
|
let window_size = WindowSize {
|
|
width: app.gpu.surface_config.width,
|
|
height: app.gpu.surface_config.height,
|
|
};
|
|
unsafe {
|
|
ffi::App_onAppWindowResized(delegate.as_mut().unwrap_unchecked(), &window_size);
|
|
}
|
|
}
|
|
Event::WindowEvent { event: WindowEvent::Moved(loc), .. } => unsafe {
|
|
ffi::App_onAppWindowMoved(delegate.as_mut().unwrap_unchecked(), loc.x, loc.y);
|
|
},
|
|
Event::WindowEvent {
|
|
event:
|
|
WindowEvent::KeyboardInput {
|
|
input: KeyboardInput { scancode, virtual_keycode: Some(key), state, .. },
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
// TODO: Handle normal keys, this will require a refactor in game runtime code
|
|
let special_key = match key {
|
|
VirtualKeyCode::F1 => SpecialKey::F1,
|
|
VirtualKeyCode::F2 => SpecialKey::F2,
|
|
VirtualKeyCode::F3 => SpecialKey::F3,
|
|
VirtualKeyCode::F4 => SpecialKey::F4,
|
|
VirtualKeyCode::F5 => SpecialKey::F5,
|
|
VirtualKeyCode::F6 => SpecialKey::F6,
|
|
VirtualKeyCode::F7 => SpecialKey::F7,
|
|
VirtualKeyCode::F8 => SpecialKey::F8,
|
|
VirtualKeyCode::F9 => SpecialKey::F9,
|
|
VirtualKeyCode::F10 => SpecialKey::F10,
|
|
VirtualKeyCode::F11 => SpecialKey::F11,
|
|
VirtualKeyCode::F12 => SpecialKey::F12,
|
|
VirtualKeyCode::Escape => SpecialKey::Esc,
|
|
VirtualKeyCode::Return => SpecialKey::Enter,
|
|
VirtualKeyCode::Back => SpecialKey::Backspace,
|
|
VirtualKeyCode::Insert => SpecialKey::Insert,
|
|
VirtualKeyCode::Delete => SpecialKey::Delete,
|
|
VirtualKeyCode::Home => SpecialKey::Home,
|
|
VirtualKeyCode::PageUp => SpecialKey::PgUp,
|
|
VirtualKeyCode::PageDown => SpecialKey::PgDown,
|
|
VirtualKeyCode::Left => SpecialKey::Left,
|
|
VirtualKeyCode::Right => SpecialKey::Right,
|
|
VirtualKeyCode::Up => SpecialKey::Up,
|
|
VirtualKeyCode::Down => SpecialKey::Down,
|
|
VirtualKeyCode::Tab => SpecialKey::Tab,
|
|
_ => SpecialKey::None,
|
|
};
|
|
|
|
if special_key != SpecialKey::None {
|
|
let pressed = state == ElementState::Pressed;
|
|
let repeat = special_keys_pressed[key as usize] == pressed;
|
|
special_keys_pressed[key as usize] = pressed;
|
|
|
|
unsafe {
|
|
if pressed {
|
|
ffi::App_onSpecialKeyDown(
|
|
delegate.as_mut().unwrap_unchecked(),
|
|
special_key,
|
|
repeat,
|
|
);
|
|
} else {
|
|
ffi::App_onSpecialKeyUp(
|
|
delegate.as_mut().unwrap_unchecked(),
|
|
special_key,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Event::MainEventsCleared => {
|
|
log::trace!("Requesting redraw");
|
|
window_ctx.window.request_redraw();
|
|
}
|
|
Event::RedrawRequested(_) => {
|
|
let io = imgui.context.io_mut();
|
|
let mut dt: f32 = 1.0 / 60.0;
|
|
if let Some(last_frame) = last_frame {
|
|
let duration = last_frame.elapsed();
|
|
dt = duration.as_secs_f32();
|
|
io.update_delta_time(duration);
|
|
}
|
|
last_frame = Some(Instant::now());
|
|
|
|
imgui
|
|
.platform
|
|
.prepare_frame(io, &window_ctx.window)
|
|
.expect("Failed to prepare frame");
|
|
let ui = imgui.context.frame();
|
|
|
|
#[allow(unused_unsafe)] // rust bug?
|
|
if !unsafe { ffi::App_onAppIdle(delegate.as_mut().unwrap(), dt) } {
|
|
*control_flow = ControlFlow::Exit;
|
|
return;
|
|
}
|
|
|
|
log::trace!("Redrawing");
|
|
let frame_result = gpu.surface.get_current_texture();
|
|
if let Err(err) = frame_result {
|
|
log::warn!("Failed to acquire frame {}", err);
|
|
return;
|
|
}
|
|
let frame = frame_result.unwrap();
|
|
|
|
#[allow(unused_unsafe)] // rust bug?
|
|
unsafe {
|
|
ffi::App_onAppDraw(delegate.as_mut().unwrap_unchecked());
|
|
}
|
|
|
|
let fb_view =
|
|
gpu.framebuffer.texture.create_view(&wgpu::TextureViewDescriptor::default());
|
|
let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
|
|
let mut encoder =
|
|
gpu.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
|
label: Some("Redraw Encoder"),
|
|
});
|
|
{
|
|
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
|
label: None,
|
|
color_attachments: &[if gpu.config.msaa_samples > 1 {
|
|
wgpu::RenderPassColorAttachment {
|
|
view: &fb_view,
|
|
resolve_target: Some(&view),
|
|
ops: wgpu::Operations {
|
|
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
|
|
store: true,
|
|
},
|
|
}
|
|
} else {
|
|
wgpu::RenderPassColorAttachment {
|
|
view: &view,
|
|
resolve_target: None,
|
|
ops: wgpu::Operations {
|
|
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
|
|
store: true,
|
|
},
|
|
}
|
|
}],
|
|
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
|
|
view: &gpu.depth.view,
|
|
depth_ops: Some(wgpu::Operations {
|
|
load: wgpu::LoadOp::Clear(1.0),
|
|
store: true,
|
|
}),
|
|
stencil_ops: None,
|
|
}),
|
|
});
|
|
|
|
render_into_pass(&mut rpass);
|
|
|
|
imgui.platform.prepare_render(&ui, &window_ctx.window);
|
|
imgui
|
|
.backend
|
|
.render(ui.render(), &gpu.queue, &gpu.device, &mut rpass)
|
|
.expect("Rendering failed");
|
|
}
|
|
|
|
gpu.queue.submit(Some(encoder.finish()));
|
|
frame.present();
|
|
|
|
#[allow(unused_unsafe)] // rust bug?
|
|
unsafe {
|
|
ffi::App_onAppPostDraw(delegate.as_mut().unwrap_unchecked());
|
|
}
|
|
}
|
|
Event::LoopDestroyed => unsafe {
|
|
ffi::App_onAppExiting(delegate.as_mut().unwrap_unchecked());
|
|
APP.take();
|
|
return;
|
|
},
|
|
_ => {}
|
|
}
|
|
|
|
imgui.platform.handle_event(imgui.context.io_mut(), &window_ctx.window, &event);
|
|
});
|
|
}
|
|
|
|
fn get_app() -> &'static mut App {
|
|
unsafe {
|
|
if let Some(ref mut app) = APP {
|
|
app
|
|
} else {
|
|
panic!("Application not initialized");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_window_context() -> &'static mut WindowContext { &mut get_app().window.inner }
|
|
|
|
fn get_args() -> Vec<String> { std::env::args().skip(1).collect() }
|
|
|
|
fn get_window_size() -> ffi::WindowSize {
|
|
let size = get_window_context().window.inner_size();
|
|
ffi::WindowSize { width: size.width, height: size.height }
|
|
}
|
|
|
|
fn set_window_title(title: &cxx::CxxString) {
|
|
get_window_context().window.set_title(&title.to_string_lossy());
|
|
}
|
|
|
|
fn get_backend() -> ffi::Backend {
|
|
match get_app().gpu.backend {
|
|
Backend::Vulkan => ffi::Backend::Vulkan,
|
|
Backend::Metal => ffi::Backend::Metal,
|
|
Backend::Dx12 => ffi::Backend::D3D12,
|
|
Backend::Dx11 => ffi::Backend::D3D11,
|
|
Backend::Gl => ffi::Backend::OpenGL,
|
|
Backend::BrowserWebGpu => ffi::Backend::WebGPU,
|
|
Backend::Empty => ffi::Backend::Invalid,
|
|
}
|
|
}
|
|
|
|
fn get_dxt_compression_supported() -> bool {
|
|
return get_app().gpu.adapter.features().contains(wgpu::Features::TEXTURE_COMPRESSION_BC);
|
|
}
|
|
|
|
fn get_backend_string() -> &'static str {
|
|
match get_app().gpu.backend {
|
|
Backend::Vulkan => "Vulkan",
|
|
Backend::Metal => "Metal",
|
|
Backend::Dx12 => "D3D12",
|
|
Backend::Dx11 => "D3D11",
|
|
Backend::Gl => "OpenGL ES",
|
|
Backend::BrowserWebGpu => "WebGPU",
|
|
Backend::Empty => "Invalid",
|
|
}
|
|
}
|
|
|
|
fn set_fullscreen(v: bool) {
|
|
get_window_context().window.set_fullscreen(if v {
|
|
Some(winit::window::Fullscreen::Borderless(None))
|
|
} else {
|
|
None
|
|
});
|
|
}
|