forestiles/src/lib.rs

// mod graphics;
// mod state;
pub mod map;
pub mod camera;
pub mod ui;

use std::{fmt::Debug, sync::Arc};

use log::debug;
// use state::State;
// use graphics::Graphics;
// use winit::{application::ApplicationHandler, dpi::PhysicalSize, event::{Event, WindowEvent}, event_loop::EventLoop, window::{Window, WindowAttributes}};
use bevy::{prelude::*, diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin}};
use bevy_inspector_egui::quick::WorldInspectorPlugin;

pub fn dbg<V: Debug>(v: V) -> V {
    debug!(target: "app", "{:?}", v);
    v
}

// struct App<'a> {
//     // event_loop: EventLoop<()>,
//     window: Option<Arc<Window>>,
//     graphics: Option<Graphics<'a>>,
//     state: State
// }
// impl App<'_> {
//     fn new() -> Self {
//         Self {
//             window: None,
//             graphics: None,
//             state: State::new()
//         }
//     }
// }

// impl ApplicationHandler for App<'_> {
//     fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
//         #[cfg(not(any(target_family = "wasm", target_os = "android")))]
//         let window = event_loop.create_window(
//                 WindowAttributes::default()
//                     .with_inner_size(PhysicalSize::new(1080*2/5, 2000*2/5))
//             ).unwrap();
//         #[cfg(target_os = "android")]
//         let window = event_loop.create_window(
//                 WindowAttributes::default()
//                     // .with_inner_size(PhysicalSize::new(1080*2/5, 2000*2/5))
//             ).unwrap();
//         self.window = Some(Arc::new(window));
//         self.graphics = Some(pollster::block_on(Graphics::init(&self.state, self.window.clone().unwrap())));
//     }
//     fn window_event(
//             &mut self,
//             event_loop: &winit::event_loop::ActiveEventLoop,
//             window_id: winit::window::WindowId,
//             event: WindowEvent,
//     ) {
//         match &event {
//             WindowEvent::CloseRequested => event_loop.exit(),
//             WindowEvent::RedrawRequested => {
//                 if let Some(g) = &mut self.graphics {
//                     self.state.update_if_needed();
//                     self.state.render(self.window.as_ref().unwrap().inner_size());
//                     g.update(&self.state);
//                     g.render(&self.state);
//                 }
//             },
//             WindowEvent::MouseWheel { delta, .. } => {
//                 dbg!(delta);
//             },
//             _ => {}
//         }
//         self.graphics.as_mut().unwrap().window_event(&event, &self.window.as_ref().unwrap());
//         self.state.window_event(&event, &self.window.as_ref().unwrap());
//     }
//     fn about_to_wait(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
//         if let Some(window) = self.window.as_ref() {
//             window.request_redraw();
//         }
//     }
// }

#[cfg(not(target_os = "android"))]
pub fn main() {
    // #[cfg(target_family = "wasm")]
    // let (event_loop, window) = {
    //     use winit::platform::web::WindowExtWebSys;
    //     std::panic::set_hook(Box::new(console_error_panic_hook::hook));
    //     console_log::init().expect("could not initialize logger");

    //     let event_loop = winit::event_loop::EventLoop::new().unwrap();
    //     let window = winit::window::WindowBuilder::new().build(&event_loop).unwrap();

    //     web_sys::window()
    //         .unwrap()
    //         .document()
    //         .unwrap()
    //         .body()
    //         .unwrap()
    //         .append_child(&window.canvas().unwrap())
    //         .unwrap();
    //     (event_loop, window)
    // };

    App::new()
        .add_plugins((
            DefaultPlugins,
            WorldInspectorPlugin::default(),
            camera::Plugin,
            map::Plugin,
            ui::Plugin,
            FrameTimeDiagnosticsPlugin,
            LogDiagnosticsPlugin {
                filter: Some(vec![FrameTimeDiagnosticsPlugin::FPS]),
                ..Default::default()
            }
        ))
        .run();
}

#[cfg(target_os = "android")]
#[no_mangle]
fn android_main(app: winit::platform::android::activity::AndroidApp) {
    use winit::platform::android::{EventLoopBuilderExtAndroid, activity::WindowManagerFlags};

    android_logger::init_once(
        android_logger::Config::default()
            .with_max_level(log::LevelFilter::Debug)
            .with_filter(android_logger::FilterBuilder::new().parse("app").build())
    );

    app.set_window_flags(WindowManagerFlags::KEEP_SCREEN_ON | WindowManagerFlags::FULLSCREEN, WindowManagerFlags::empty());

    let event_loop = winit::event_loop::EventLoopBuilder::new()
        .with_android_app(app)
        .build()
        .unwrap();

    event_loop.run_app(&mut App::new()).unwrap();
}