path: root/src/main.rs

#![deny(unsafe_code)]
use std::cell::OnceCell;
use vulkanalia::{ Entry, Instance, Version };
use vulkanalia::loader::{ LibloadingLoader, LIBRARY };
use vulkanalia::vk::{ self, HasBuilder,
                      ApplicationInfo, InstanceCreateInfo,
                      DeviceV1_4, EntryV1_4, InstanceV1_4 };
use winit::dpi::LogicalSize;
use winit::application::ApplicationHandler;
use winit::event::WindowEvent;
use winit::event_loop::{ ActiveEventLoop, EventLoop };
use winit::window::{ Window, WindowAttributes, WindowId };

#[derive(Debug)]
struct Error {
  message: String,
}
type Result<T> = std::result::Result<T, Error>;

impl std::fmt::Display for Error {
  fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>)
      -> std::result::Result<(), std::fmt::Error>
  {
    fmt.write_str(&self.message)
  }
}

impl From<winit::error::EventLoopError> for Error {
  fn from(e: winit::error::EventLoopError) -> Self {
    match e {
      winit::error::EventLoopError::NotSupported(e) => Self::from(e),
      winit::error::EventLoopError::Os(e) => Self::from(e),
      winit::error::EventLoopError::RecreationAttempt => Error {
        message:
            "There may only ever be a single winit event loop.".to_string()
      },
      winit::error::EventLoopError::ExitFailure(code) => Error {
        message:
            format!("Clean unhappy exit with code {} via winit event loop",
                    code)
      }
    }
  }
}

impl From<winit::error::NotSupportedError> for Error {
  fn from(e: winit::error::NotSupportedError) -> Self {
    Error {
      message:
          format!("The winit backend does not support an operation: {}",
                  e.to_string())
    }
  }
}

impl From<winit::error::OsError> for Error {
  fn from(e: winit::error::OsError) -> Self {
    Error {
      message: format!("The OS told winit about an error: {}", e.to_string())
    }
  }
}

impl From<libloading::Error> for Error {
  fn from(e: libloading::Error) -> Self {
    Error {
      message: format!("The dynamic object loader reported an error: {}",
                       e.to_string())
    }
  }
}

impl From<Box<dyn vulkanalia::loader::LoaderError>> for Error {
  fn from(e: Box<dyn vulkanalia::loader::LoaderError>) -> Self {
    Error {
      message: format!("The Vulkan loader reported an error: {}",
                       e.to_string())
    }
  }
}

impl From<vulkanalia::vk::ErrorCode> for Error {
  fn from(e: vulkanalia::vk::ErrorCode) -> Self {
    Error {
      message: format!("Vulkan gave an error code: {}", e.to_string())
    }
  }
}

fn ignore_errors(mut body: impl FnMut() -> Result<()>) -> () {
  if let Err(e) = body() {
    eprintln!("Error: {}", e);
  }
}


const VULKAN_FIRST_PORTABILITY_VERSION: Version = Version::new(1, 3, 216);


struct Surreality {
  window: OnceCell<Window>,
  entry: OnceCell<Entry>,
  instance: OnceCell<Instance>,
}

impl Surreality {
  fn new() -> Self {
    Surreality {
      window: OnceCell::new(),
      entry: OnceCell::new(),
      instance: OnceCell::new(),
    }
  }

  fn init(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
    if self.window.get().is_none() {
      self.init_window(event_loop)?;
    }

    if self.entry.get().is_none() {
      self.init_entry()?;
    }

    if self.instance.get().is_none() {
      self.init_instance()?;
    }

    Ok(())
  }

  fn init_window(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
    let window_attributes = WindowAttributes::default()
            .with_title("Love, Curiosity, Justice")
            .with_inner_size(LogicalSize::new(1024, 768));

    let window: Window = event_loop.create_window(window_attributes)?;

    let _ = self.window.set(window);

    Ok(())
  }

  fn init_entry(&mut self) -> Result<()> {
    #[allow(unsafe_code)]
    let loader = unsafe { LibloadingLoader::new(LIBRARY)? };
    #[allow(unsafe_code)]
    let entry = unsafe { Entry::new(loader)? };

    let _ = self.entry.set(entry);

    Ok(())
  }

  fn init_instance(&mut self) -> Result<()> {
    let entry = self.entry.get().unwrap();

    let application_info = ApplicationInfo::builder()
      .application_name(b"Surreality\0")
      .application_version(vk::make_version(1, 0, 0))
      .engine_name(b"Surreality\0")
      .engine_version(vk::make_version(1, 0, 0))
      .api_version(vk::make_version(1, 0, 0));

    let mut extensions = vulkanalia::window::get_required_instance_extensions(
                         self.window.get().unwrap())
        .iter().map(|item| item.as_ptr()).collect::<Vec<_>>();

    let mut flags = vk::InstanceCreateFlags::empty();
    if entry.version()? >= VULKAN_FIRST_PORTABILITY_VERSION {
      if cfg!(target_os = "macos") {
        // Vulkan on the Mac is not fully conforming.
        extensions.push(
            vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_EXTENSION.name.as_ptr());
        extensions.push(
            vk::KHR_PORTABILITY_ENUMERATION_EXTENSION.name.as_ptr());
        flags.insert(vk::InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR);
      }
    }

    let instance_create_info = InstanceCreateInfo::builder()
      .application_info(&application_info)
      .enabled_extension_names(&extensions)
      .flags(flags);

    #[allow(unsafe_code)]
    let instance = unsafe {
      entry.create_instance(&instance_create_info, None)?
    };

    let _ = self.instance.set(instance);

    Ok(())
  }

  fn render(&mut self, window_id: WindowId) -> Result<()> {
    if let Some(window) = self.window.get()
       && window_id == window.id()
    {
      println!("render the window");
    } else {
      println!("render something unknown");
    }

    Ok(())
  }
}

impl ApplicationHandler for Surreality {
  fn resumed(&mut self, event_loop: &ActiveEventLoop) {
    ignore_errors(move || {
      println!("resumed");
      self.init(event_loop)?;

      Ok(())
    });
  }

  fn window_event(&mut self, event_loop: &ActiveEventLoop,
                  window_id: WindowId, event: WindowEvent)
  {
    println!("window event {:?}", event);

    match event {
      WindowEvent::RedrawRequested => {
        if !event_loop.exiting() {
          if let Err(e) = self.render(window_id) {
            eprintln!("Error: {}", e);
          }
        }
      }
      WindowEvent::CloseRequested => {
        event_loop.exit();
      }
      _ => { }
    }
  }
}


fn main() -> std::process::ExitCode {
  let body: fn() -> Result<()> = || {
    let event_loop = EventLoop::new()?;
    let mut surreality = Surreality::new();
    event_loop.run_app(&mut surreality)?;
    Ok(())
  };

  match body() {
    Ok(()) => std::process::ExitCode::SUCCESS,
    Err(e) => {
      eprintln!("Error: {}", e);
      std::process::ExitCode::from(1)
    }
  }
}