path: root/src/main.rs

#![deny(unsafe_code)]
use crate::error::*;

use std::cell::OnceCell;
use std::collections::{ BTreeMap, BTreeSet, HashSet };
use std::ffi::{ c_void, CStr };
use vulkanalia::{ Device, Entry, Instance, Version };
use vulkanalia::loader::{ LibloadingLoader, LIBRARY };
use vulkanalia::vk::{ self, Handle, HasBuilder,
                      ApplicationInfo, InstanceCreateInfo,
                      DeviceV1_0, EntryV1_0, InstanceV1_0,
                      ExtDebugUtilsExtensionInstanceCommands,
                      KhrSurfaceExtensionInstanceCommands,
                      KhrSwapchainExtensionDeviceCommands };
use winit::dpi::LogicalSize;
use winit::application::ApplicationHandler;
use winit::event::WindowEvent;
use winit::event_loop::{ ActiveEventLoop, EventLoop };
use winit::window::{ Window, WindowAttributes, WindowId };

mod error;


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


enum Acceptable<T> {
  Accepted(T),
  Rejected(String),
}

impl<T> Acceptable<T> {
  #[allow(unused)]
  fn is_accepted(&self) -> bool {
    if let Acceptable::Accepted(_) = self { true } else { false }
  }

  #[allow(unused)]
  fn is_rejected(&self) -> bool {
    if let Acceptable::Rejected(_) = self { true } else { false }
  }

  fn unwrap(self) -> T {
    if let Acceptable::Accepted(result) = self {
      result
    } else {
      panic!("Unwrapped a rejected Acceptable.");
    }
  }
}

#[derive(Debug)]
struct QueueFamilyIndices {
  graphics: u32,
  presentation: u32,
}

#[derive(Debug)]
struct SwapchainFeatures {
  capabilities: vk::SurfaceCapabilitiesKHR,
  formats: Vec<vk::SurfaceFormatKHR>,
  presentation_modes: Vec<vk::PresentModeKHR>,
}


struct Surreality {
  //   The "window" is the usual operating-system concept of a window; it's
  // provided by winit, and may be X11, Wayland, or some more curious thing.
  // The way we initialize Vulkan requires us to have at least one of these;
  // we could have more, but for now, we don't.
  window: OnceCell<Window>,

  //   There are a few Vulkan features (in the informal sense of "feature")
  // that we want to be able to run both with and without. Here, we have
  // booleans describing which we're doing. These are computed during instance
  // and device initialization.
  //
  //   In the cases of validation and portability, the booleans are only used
  // to communicate between initialization phases, and aren't actually needed
  // during rendering. We keep them around anyway though because they're small
  // and it's more convenient to have them all in one place.
  enable_validation: OnceCell<bool>,
  enable_portability: OnceCell<bool>,
  enable_swapchain: OnceCell<bool>,

  //   The Vulkan "entry" is the part of the Vulkan library ecosystem that's
  // responsible for finding and loading the other parts.
  entry: OnceCell<Entry>,

  //   The Vulkan "instance" is the bulk of the Vulkan library, with most of
  // the high-level responsibilities around lifecycle management.
  instance: OnceCell<Instance>,

  //   The debug messager is a Vulkan object representing our callback which
  // Vulkan uses to tell us things.
  //
  //   Vulkan spells "messager" as "messenger", but this is absurd
  // over-formality and we don't indulge it.
  debug_messager: OnceCell<vk::DebugUtilsMessengerEXT>,

  //   The Vulkan "surface" is the destination that rendering happens into.
  // It is connected to the window but distinct from it.
  surface: OnceCell<vk::SurfaceKHR>,

  //   The Vulkan "device" is the abstraction for a GPU. A physical one is the
  // actual GPU, and a logical one is our connection to it. We track both.
  // We'll be referencing the logical device a lot, so we follow Vulkan's lead
  // and let it have a short variable name.
  physical_device: OnceCell<vk::PhysicalDevice>,
  device: OnceCell<Device>,

  //   Vulkan has a first-class concept of command queues. We have two of
  // them, one for graphics drawing commands and one for presentation.
  //
  //   While these are often the same queue, there is no guarantee of that;
  // sometimes there's no queue family that supports both operations together.
  // For simplicity's sake we treat them as if they're separate, though the
  // handles will alias each other when the initialization logic was able to
  // find a family that does both.
  //
  //   Yes, this means the compiler has to deal with pointer aliasing
  // concerns, which have a tendency to defeat optimizations.
  graphics_queue: OnceCell<vk::Queue>,
  presentation_queue: OnceCell<vk::Queue>,

  //   A swapchain is the generalized facility that is used to implement
  // double buffering, triple buffering, rendering passes that feed into each
  // other, and other things of that nature. It's a first-class thing but for
  // now, we use at most one of it. We also support running without one.
  swapchain: OnceCell<vk::SwapchainKHR>,
}

impl Surreality {
  fn new() -> Self {
    Surreality {
      window: OnceCell::new(),
      enable_validation: OnceCell::new(),
      enable_portability: OnceCell::new(),
      enable_swapchain: OnceCell::new(),
      entry: OnceCell::new(),
      instance: OnceCell::new(),
      debug_messager: OnceCell::new(),
      surface: OnceCell::new(),
      physical_device: OnceCell::new(),
      device: OnceCell::new(),
      graphics_queue: OnceCell::new(),
      presentation_queue: OnceCell::new(),
      swapchain: 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_vulkan_entry()?;
    }

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

    if self.surface.get().is_none() {
      self.init_vulkan_surface()?;
    }

    if self.device.get().is_none() {
      self.init_vulkan_device()?;
    }

    if self.swapchain.get().is_none()
       && *self.enable_swapchain.get().unwrap()
    {
      self.init_vulkan_swapchain()?;
    }

    Ok(())
  }

  fn init_window(&mut self, event_loop: &ActiveEventLoop) -> Result<()> {
    //   Notice that we do this before having a Vulkan instance. The window is
    // actually a parameter needed to create the instance; see
    // init_vulkan_instance(), below.
    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)?;

    self.window.set(window).unwrap();

    Ok(())
  }

  #[allow(unsafe_code)]
  fn init_vulkan_entry(&mut self) -> Result<()> {
    //   Okay, so, a Vulkan "entry" is a small set of functions which are used
    // to dynamically load all the rest of Vulkan. It's our responsibility to
    // know how to load the entry, then it will take care of the rest. At
    // least, that's the theory, but also see flake.nix for all the
    // FHS-centric assumptions it makes that we have to correct.
    //
    //   Anyway, Vulkanalia offers an integration with libloading, which is a
    // crate that wraps POSIX dlopen(). We use that; it's enabled by
    // Vulkanalia's "libloading" feature.
    let loader = unsafe { LibloadingLoader::new(LIBRARY) }?;
    let entry = unsafe { Entry::new(loader) }?;

    self.entry.set(entry).unwrap();

    Ok(())
  }

  #[allow(unsafe_code)]
  fn init_vulkan_instance(&mut self) -> Result<()> {
    let entry = self.entry.get().unwrap();

    let enable_validation = cfg!(feature = "vulkan-validation")
                            || cfg!(debug_assertions);

    //   Since there's a lot of factors going into our instance creation
    // request, we'll build up the parameters mutably.
    let mut flags = vk::InstanceCreateFlags::empty();
    let mut extensions = Vec::new();
    let mut layers = Vec::new();

    //   Before we go any further, use Vulkan's introspection to list off
    // what's available.
    let mut available_extensions = HashSet::new();
    for extension in
            unsafe { entry.enumerate_instance_extension_properties(None) }?
    {
      available_extensions.insert(extension.extension_name);
    }
    let available_extensions = available_extensions;

    let mut available_layers = HashSet::new();
    for layer in unsafe { entry.enumerate_instance_layer_properties() }? {
      available_layers.insert(layer.layer_name);
    }
    let available_layers = available_layers;

    //   There are certain extensions which are required by the nature of our
    // windowing system. Happily, vulanaklia knows how to deal with that based
    // on the type of window we give it.
    //
    //   This is possible because of an integration between Vulkanalia and
    // winit, which is enabled by Vulkanalia's "window" feature.
    for extension in vulkanalia::window::get_required_instance_extensions(
                         self.window.get().unwrap())
    {
      extensions.push(extension.as_ptr());
    }

    //   Deal with Vulkan's thing about opting in to non-conforming
    // implementations.
    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);

        self.enable_portability.set(true).unwrap();
      } else {
        self.enable_portability.set(false).unwrap();
      }
    } else {
      self.enable_portability.set(false).unwrap();
    }

    // Request the LunarG validation layer, when appropriate.
    if enable_validation {
      let layer_name = vk::ExtensionName::from_bytes(
                           b"VK_LAYER_KHRONOS_validation");
      if available_layers.contains(&layer_name) {
        layers.push(layer_name.as_ptr());

        self.enable_validation.set(enable_validation).unwrap();
      } else {
        eprintln!("Vulkan validation requested at build time, \
                   but no validation layer available.");

        self.enable_validation.set(false).unwrap();
      }
    } else {
      self.enable_validation.set(false).unwrap();
    }

    //   Request the debug extension. This is the first of three bits of code
    // that deal with this, and has the resonsibility of making sure the
    // extension is in the list we ask for.
    let debug_extension_name = vk::EXT_DEBUG_UTILS_EXTENSION.name;
    if available_extensions.contains(&debug_extension_name) {
      extensions.push(debug_extension_name.as_ptr());
    } else {
      eprintln!("Vulkan debug extension not available; \
                 this may mean other messages don't show up.");
    }

    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));

    //   Deceptively, this DOES get mutated later, but Vulkanalia doesn't see
    // it that way.
    let instance_create_info = InstanceCreateInfo::builder()
            .application_info(&application_info)
            .flags(flags)
            .enabled_extension_names(&extensions)
            .enabled_layer_names(&layers);

    //   Configure the debug extension. This is the middle of three bits of
    // code that deal with this, and has the responsibility of making sure
    // the callback will be available during instance creation and
    // destruction, which is done in a special way that doesn't rely on having
    // a messager, since there can't be one for those steps.
    let debug_info = if available_extensions.contains(&debug_extension_name) {
      let mut debug_info = vk::DebugUtilsMessengerCreateInfoEXT::builder()
              .message_severity(vk::DebugUtilsMessageSeverityFlagsEXT::all())
              .message_type(vk::DebugUtilsMessageTypeFlagsEXT::GENERAL
                            | vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION
                            | vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE)
              .user_callback(Some(debug_messager_callback));

      //   Please notice that the reference we pass here will escape Rust's
      // lifetime checking, since push_next() casts it to a pointer. We don't
      // get nearly as strong a safety guarantee as one might hope (and as [1]
      // naively reassures us we do). If we did, the thing we're doing would
      // actually be forbidden!
      //
      // [1] https://kylemayes.github.io/vulkanalia/
      instance_create_info.push_next(&mut debug_info);

      Some(debug_info)
    } else { None };

    let instance = unsafe {
      //   We're promising that every struct referenced here is still alive.
      // Since it's all pointers, that's... not a thing we statically know. Be
      // aware. Only you can prevent segfaults.
      entry.create_instance(&instance_create_info, None)
    }?;

    //   Configure the debug extension. This is the last of three bits of code
    // that deal with this, and has the responsibility of asking the instance,
    // which now exists, to create the debug messager.
    if let Some(debug_info) = debug_info
       && self.debug_messager.get().is_none()
    {
      #[allow(unsafe_code)]
      let debug_messager = unsafe {
        instance.create_debug_utils_messenger_ext(&debug_info, None)
      }?;

      self.debug_messager.set(debug_messager).unwrap();
    }

    self.instance.set(instance).unwrap();

    Ok(())
  }

  #[allow(unsafe_code)]
  fn init_vulkan_surface(&mut self) -> Result<()> {
    let window = self.window.get().unwrap();
    let instance = self.instance.get().unwrap();

    //   Conveniently, Vulkanalia's "window" feature allows it to get the
    // platform-specific stuff directly out of winit for us. This wrapper does
    // not correspond 1:1 to a Vulkan function; rather, it picks the Vulkan
    // function from the appropriate platform-specific extension.
    //
    //   The reason it takes the window twice is that that first one is
    // actually there to reference the display (in the x11 sense of "display"
    // meaning the connection to the windowing system).
    let surface = unsafe {
      vulkanalia::window::create_surface(&instance, &window, &window)
    }?;

    self.surface.set(surface).unwrap();

    Ok(())
  }

  #[allow(unsafe_code)]
  fn init_vulkan_device(&mut self) -> Result<()> {
    if self.physical_device.get().is_none() {
      let physical_device = self.pick_vulkan_device()?;

      self.physical_device.set(physical_device).unwrap();
    }

    if self.device.get().is_none() {
      //   Usually we're content to borrow these, but here, that would give us
      // ownership problems. In reality they are smart pointer objects that do
      // not directly contain their substantive pieces, so we can freely clone
      // them, and in this case it's convenient to do that.
      let instance = self.instance.get().unwrap().clone();
      let physical_device = self.physical_device.get().unwrap().clone();

      //   We already did the check in score_vulkan_device(), so if it fails
      // this second time, that's our own bug and we don't need to explain it
      // to our users.
      let indices = self.find_device_queue_family_indices(&physical_device)?
                        .unwrap();

      //   We enumerate the device extensions here so they can inform
      // configuration. We already did this in score_vulkan_device(), but here
      // it is again.
      let mut available_extensions = HashSet::new();
      for extension in unsafe {
        instance.enumerate_device_extension_properties(physical_device, None)
      }? {
        available_extensions.insert(extension.extension_name);
      }
      let available_extensions = available_extensions;

      //   Old versions of Vulkan want layers to be enabled at the device
      // level as well. Newer ones will ignore this and just use the instance
      // layers.
      let features = vk::PhysicalDeviceFeatures::builder();
      let mut extensions = Vec::new();
      let mut layers = Vec::new();

      if *self.enable_validation.get().unwrap() {
        let layer_name = vk::ExtensionName::from_bytes(
                             b"VK_LAYER_KHRONOS_validation");
        //   It's not concerning if this isn't supported, because device
        // layers are ignored on recent versions, they're purely historical.
        if available_extensions.contains(&layer_name) {
          layers.push(layer_name.as_ptr());
        }
      }

      if *self.enable_portability.get().unwrap() {
        //   This is untested, since the only scenario where it would come up
        // is on a Mac, which we don't actually support. Sorry, and good luck.
        let layer_name = vk::ExtensionName::from_bytes(
                             b"VK_KHR_portability_subset");
        if available_extensions.contains(&layer_name) {
          extensions.push(layer_name.as_ptr());
        }
      }

      {
        let layer_name = vk::KHR_SWAPCHAIN_EXTENSION.name;
        if available_extensions.contains(&layer_name) {
          //   It's important that we not call the swapchain extension
          // functions until we've verified the extension is supported. To
          // emphasize that, we do it on a separate line.
          //
          //   We've done this check once already, in scoring, and now here
          // we are discarding its results a second time. We'll do it for the
          // third and last time in swapchain creation.
          if let Acceptable::Accepted(_)
                 = self.find_device_swapchain_features(&physical_device)?
          {
            extensions.push(layer_name.as_ptr());

            self.enable_swapchain.set(true).unwrap();
          } else {
            self.enable_swapchain.set(false).unwrap();
          }
        } else {
          self.enable_swapchain.set(false).unwrap();
        }
      }

      //   We have one or more queue family indices; we don't know a priori
      // how many, because it's possible some of them are the same. We only
      // want to create one queue per distinct family, so we find the unique
      // indices...
      let mut unique_queue_family_indices = BTreeSet::new();
      unique_queue_family_indices.insert(indices.graphics);
      unique_queue_family_indices.insert(indices.presentation);

      // ... then add a queue create info struct for each.
      let mut queues = Vec::new();
      for index in unique_queue_family_indices {
        //   Passing the priorities vector also implicitly sets the count of
        // how many queues we are creating within the family. This nicety is
        // one of the fun things Vulkanalia's builders do for us.
        queues.push(vk::DeviceQueueCreateInfo::builder()
                        .queue_family_index(index)
                        .queue_priorities(&[1.0]));
      }

      let device_info = vk::DeviceCreateInfo::builder()
              .queue_create_infos(&queues)
              .enabled_layer_names(&layers)
              .enabled_extension_names(&extensions)
              .enabled_features(&features);

      let device = unsafe {
        instance.create_device(*self.physical_device.get().unwrap(),
                               &device_info, None)
      }?;

      //   So, this is a little confusing. Queues are found in queue families.
      // The family has an index within the device, and the queue has an index
      // within the family. We computed the family index above, and when we
      // created the device we told it to create just a single queue in that
      // family. Now we pass both indices to find the actual queue object.
      let graphics_queue = unsafe {
        device.get_device_queue(indices.graphics, 0)
      };

      let presentation_queue = unsafe {
        device.get_device_queue(indices.presentation, 0)
      };

      self.device.set(device).unwrap();
      self.graphics_queue.set(graphics_queue).unwrap();
      self.presentation_queue.set(presentation_queue).unwrap();
    }

    Ok(())
  }

  #[allow(unsafe_code)]
  fn init_vulkan_swapchain(&mut self) -> Result<()> {
    // Here, too, we need to clone the smart pointer to simplify ownership.
    let physical_device = self.physical_device.get().unwrap().clone();

    if let Acceptable::Accepted(features)
           = self.find_device_swapchain_features(&physical_device)?
    {
      let physical_device = self.physical_device.get().unwrap().clone();
      let device = self.device.get().unwrap().clone();
      let surface = self.surface.get().unwrap().clone();

      println!("features {:?}", features);

      let format = self.pick_surface_format(&features.formats)?;

      let presentation_mode
              = self.pick_presentation_mode(&features.presentation_modes)?;
      let extent = self.pick_image_extent(features.capabilities)?;

      let mut image_count = features.capabilities.min_image_count + 1;
      if features.capabilities.max_image_count != 0 {
        image_count
            = image_count.clamp(0, features.capabilities.max_image_count);
      }

      //   We call this one last time. It needs to return the same thing here
      // that it did before; fortunately it's simple enough that that's a safe
      // assumption.
      let indices = self.find_device_queue_family_indices(&physical_device)?
                        .unwrap();

      let mut unique_queue_family_indices = BTreeSet::new();
      unique_queue_family_indices.insert(indices.graphics);
      unique_queue_family_indices.insert(indices.presentation);

      //   If there's only one queue, we use exclusive sharing mode, which
      // will allow things to work without locks. Otherwise we use concurrent
      // mode.
      let (ordered_indices, sharing_mode)
              = if unique_queue_family_indices.len() < 2
      {
        (vec![indices.graphics], vk::SharingMode::EXCLUSIVE)
      } else {
        (vec![indices.graphics, indices.presentation],
         vk::SharingMode::CONCURRENT)
      };

      let swapchain_info = vk::SwapchainCreateInfoKHR::builder()
              .surface(surface)
              .min_image_count(image_count)
              .image_format(format.format)
              .image_color_space(format.color_space)
              .image_extent(extent)
              .image_array_layers(1)
              .image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
              .image_sharing_mode(sharing_mode)
              .queue_family_indices(&ordered_indices)
              .pre_transform(features.capabilities.current_transform)
              .composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
              .present_mode(presentation_mode)
              .clipped(true)
              .old_swapchain(vk::SwapchainKHR::null());

      let swapchain = unsafe {
        device.create_swapchain_khr(&swapchain_info, None)
      }?;
      println!("swapchain {:?}", swapchain);

      self.swapchain.set(swapchain).unwrap();
    }

    Ok(())
  }

  //   To Vulkan, a "physical" device is the actual GPU, and a "logical"
  // device is per-process state that represents a connection to the GPU.
  // Before we can create a logical device, we must choose which physical
  // device to connect it to.
  #[allow(unsafe_code)]
  fn pick_vulkan_device(&mut self) -> Result<vk::PhysicalDevice> {
    let mut best_device = None;
    let mut best_score = None;
    let mut rejected = BTreeMap::new();

    for device in unsafe {
      self.instance.get().unwrap().enumerate_physical_devices()
    }? {
      match self.score_vulkan_device(&device)? {
        Acceptable::Accepted(new_score) => {
          if let Some(old_score) = best_score {
            if new_score > old_score {
              best_device = Some(device);
              best_score = Some(new_score);
            }
          } else {
            best_device = Some(device);
            best_score = Some(new_score);
          }
        }
        Acceptable::Rejected(reason) => {
          let properties = unsafe {
            self.instance.get().unwrap()
                .get_physical_device_properties(device)
          };

          let name = properties.device_name.to_string_lossy().into_owned();

          rejected.insert(properties.device_id, (name, reason));
        }
      }
    }

    if let Some(device) = best_device {
      Ok(device)
    } else if rejected.is_empty() {
      Err(Error {
        message: "The system has no GPUs of any kind.".to_string()
      })
    } else {
      for (_, (name, reason)) in rejected {
        eprintln!("Can't run on {} because: {}", name, reason);
      }

      Err(Error {
        message: "The system has GPUs, but none are acceptable (see above)."
                 .to_string()
      })
    }
  }

  //   We're doing two tasks: Quantifying how strongly we prefer a device, and
  // deciding whether it's acceptable at all. If it's unacceptable, it's
  // possible there will be no acceptable devices, and in that case our caller
  // will want to print explanations, but otherwise it'll want to be quiet. So
  // the outer Result is whether we successfully evaluated the device, and the
  // inner Acceptable is whether we approve of it.
  #[allow(unsafe_code)]
  fn score_vulkan_device(&mut self, device: &vk::PhysicalDevice)
      -> Result<Acceptable<u64>>
  {
    //   Not all devices support graphics, and not all devices support
    // presenting to any given surface. We check whether this one is suitable
    // by looking up the indices of the queue families we would use, though
    // we ignore the actual values and recompute them later.
    if let Acceptable::Rejected(rationale)
           = self.find_device_queue_family_indices(device)?
    {
      return Ok(Acceptable::Rejected(rationale));
    }

    let instance = self.instance.get().unwrap();

    //   At this point we know the device meets our high-level requirements,
    // so it's just a question of scoring.
    let properties = unsafe {
      instance.get_physical_device_properties(*device)
    };

    let mut score = 0;
    if properties.device_type == vk::PhysicalDeviceType::DISCRETE_GPU {
      // If the user has a fancy GPU, they prefer it.
      score += 128;
    } else if properties.device_type
                  == vk::PhysicalDeviceType::INTEGRATED_GPU
    {
      // It's still hardware rendering.
      score += 96;
    } else if properties.device_type == vk::PhysicalDeviceType::VIRTUAL_GPU {
      // Whatever it is, the user went to some trouble to set it up.
      score += 64;
    } else if properties.device_type == vk::PhysicalDeviceType::CPU {
      // Software rendering is slow, but at least it's a known quantity.
      score += 32;
    }
    // If it's none of those, we don't have enough information to know if
    // that's good or bad, so we assume it's bad.

    //   Some of our scoring will depend on what extensions the device
    // supports, so we enumerate those.
    let mut available_extensions = HashSet::new();
    for extension in unsafe {
      instance.enumerate_device_extension_properties(*device, None)
    }? {
      available_extensions.insert(extension.extension_name);
    }
    let available_extensions = available_extensions;

    if available_extensions.contains(&vk::KHR_SWAPCHAIN_EXTENSION.name) {
      //   Double buffering is both quite a nice feature to have, and a good
      // indicator that this is a "real" graphics card rather than some
      // trivial weird thing.
      //
      //   With that said, however, it only counts if we're able to actually
      // use it on the surface we have. Let's find out...
      if let Acceptable::Accepted(_)
             = self.find_device_swapchain_features(device)?
      {
        //   We don't count it for enough points to override a device type
        // bracket, but it's good for a lot within the bracket.
        score += 16;
      }

      //   This isn't disqualifying, so we don't worry about tracking the
      // rationale. We'll deal with that later, if the device actually gets
      // selected.
    }

    Ok(Acceptable::Accepted(score))
  }

  #[allow(unsafe_code)]
  fn find_device_queue_family_indices(&mut self, device: &vk::PhysicalDevice)
      -> Result<Acceptable<QueueFamilyIndices>>
  {
    let instance = self.instance.get().unwrap();
    let surface = self.surface.get().unwrap();

    //   We need a queue family that supports graphics drawing commands, and a
    // queue family that supports presentation commands. These may or may not
    // be the same family.
    let mut graphics = None;
    let mut presentation = None;

    for (index, queue_family) in (unsafe {
      instance.get_physical_device_queue_family_properties(*device)
    }).into_iter().enumerate() {
      if graphics.is_none()
         && queue_family.queue_flags.contains(vk::QueueFlags::GRAPHICS)
      {
        graphics = Some(index as u32);
      }

      if presentation.is_none() && unsafe {
        instance.get_physical_device_surface_support_khr(
            *device, index as u32, *surface)
      }? {
        presentation = Some(index as u32);
      }
    }

    if let Some(graphics) = graphics {
      if let Some(presentation) = presentation {
        Ok(Acceptable::Accepted(QueueFamilyIndices {
          graphics, presentation
        }))
      } else {
        Ok(Acceptable::Rejected(
            "Doesn't support presenting to our window.".to_string()))
      }
    } else {
      Ok(Acceptable::Rejected("Doesn't support graphics.".to_string()))
    }
  }

  //   We expect our caller to have already verified that the device supports
  // the swapchain extension.
  #[allow(unsafe_code)]
  fn find_device_swapchain_features(&mut self, device: &vk::PhysicalDevice)
      -> Result<Acceptable<SwapchainFeatures>>
  {
    let instance = self.instance.get().unwrap();
    let surface = self.surface.get().unwrap();

    let capabilities = unsafe {
      instance.get_physical_device_surface_capabilities_khr(
          *device, *surface)
    }?;
    let formats = unsafe {
      instance.get_physical_device_surface_formats_khr(
          *device, *surface)
    }?;
    let presentation_modes = unsafe {
      instance.get_physical_device_surface_present_modes_khr(
          *device, *surface)
    }?;

    if formats.is_empty() {
      Ok(Acceptable::Rejected("No matching surface formats.".to_string()))
    } else if presentation_modes.is_empty() {
      Ok(Acceptable::Rejected("No matching presentation modes.".to_string()))
    } else {
      Ok(Acceptable::Accepted(SwapchainFeatures {
        capabilities, formats, presentation_modes
      }))
    }
  }

  fn pick_surface_format(&mut self,
                         available_formats: &Vec<vk::SurfaceFormatKHR>)
      -> Result<vk::SurfaceFormatKHR>
  {
    for format in available_formats {
      if format.format == vk::Format::B8G8R8A8_SRGB
         && format.color_space == vk::ColorSpaceKHR::SRGB_NONLINEAR
      {
        return Ok(format.clone());
      }
    }

    return Ok(available_formats[0].clone());
  }

  fn pick_presentation_mode(&mut self,
                            _available_modes: &Vec<vk::PresentModeKHR>)
      -> Result<vk::PresentModeKHR>
  {
    // It's guaranteed to have this one.
    return Ok(vk::PresentModeKHR::FIFO);
  }

  fn pick_image_extent(&mut self, capabilities: vk::SurfaceCapabilitiesKHR)
      -> Result<vk::Extent2D>
  {
    if capabilities.current_extent.width != u32::MAX
       && capabilities.current_extent.height != u32::MAX
    {
      Ok(capabilities.current_extent)
    } else {
      let window = self.window.get().unwrap();
      let window_size = window.inner_size();

      let width = window_size.width
                             .clamp(capabilities.min_image_extent.width,
                                    capabilities.max_image_extent.width);
      let height = window_size.height
                              .clamp(capabilities.min_image_extent.height,
                                     capabilities.max_image_extent.height);

      Ok(vk::Extent2D::builder().width(width).height(height).build())
    }
  }

  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 Drop for Surreality {
  #[allow(unsafe_code)]
  fn drop(&mut self) {
    if let Some(swapchain) = self.swapchain.get()
       && let Some(device) = self.device.get()
    {
      unsafe { device.destroy_swapchain_khr(*swapchain, None) };
    }

    if let Some(surface) = self.surface.get()
       && let Some(instance) = self.instance.get()
    {
      unsafe { instance.destroy_surface_khr(*surface, None) };
    }

    if let Some(device) = self.device.get() {
      unsafe { device.destroy_device(None) };
    }

    //   Everything but the instance itself should already be destroyed,
    // before we destroy the debug messager. The special hook to get debug
    // messages while destroying the instance itself only applies to the
    // instance and the messager, so if we were to destroy anything we
    // shouldn't after this point, we'd miss out on diagnostics.
    if let Some(debug_messager) = self.debug_messager.get()
       && let Some(instance) = self.instance.get()
    {
      unsafe {
        instance.destroy_debug_utils_messenger_ext(*debug_messager, None);
      }
    }

    if let Some(instance) = self.instance.get() {
      unsafe { instance.destroy_instance(None) };
    }
  }
}

impl ApplicationHandler for Surreality {
  fn resumed(&mut self, event_loop: &ActiveEventLoop) {
    ignore_errors(move || {
      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)
    }
  }
}


#[allow(unsafe_code)]
extern "system" fn debug_messager_callback(
    severity: vk::DebugUtilsMessageSeverityFlagsEXT,
    flags: vk::DebugUtilsMessageTypeFlagsEXT,
    data: *const vk::DebugUtilsMessengerCallbackDataEXT,
    _context: *mut c_void) -> vk::Bool32
{
  //   Vulkan sends us everything, it's up to us to apply any filtering we
  // want. The thing about this is that games need to be debuggable by end
  // users, to diagnose compatibility issues and weird configurations, so we
  // still want SOMETHING even when we're built in release mode.
  //
  //   For now, we'll see if we can get away without providing runtime config
  // stuff for diagnostics. We set the threshold pretty high in release mode,
  // on the theory that our own diagnostics should be sufficient.
  //
  //   Making this strategy work does rely on us actually checking error
  // conditions and reporting them in useful ways, so that we only need
  // Vulkan's messages for things we truly couldn't have anticipated. We do
  // not take a more-is-better approach to diagnostics; the ideal would be to
  // provide all the crucial information, and nothing else.
  let threshold = if cfg!(feature = "vulkan-validation")
                     || cfg!(debug_assertions)
  {
    vk::DebugUtilsMessageSeverityFlagsEXT::WARNING
  } else {
    vk::DebugUtilsMessageSeverityFlagsEXT::ERROR
  };

  if severity >= threshold {
    let data = unsafe { *data };
    let text = unsafe { CStr::from_ptr(data.message) }.to_string_lossy();

    let label = if severity >= vk::DebugUtilsMessageSeverityFlagsEXT::ERROR {
      "error"
    } else if severity >= vk::DebugUtilsMessageSeverityFlagsEXT::WARNING {
      "warning"
    } else if severity >= vk::DebugUtilsMessageSeverityFlagsEXT::INFO {
      "informational message"
    } else {
      "message of unknown, very minor significance"
    };

    eprintln!("Vulkan {}: {} (flags {:?})", label, text, flags);
  }

  //   A return value of true would tell the validation layer we're unhappy
  // with it, for the sake of conformance testing. We're not a conformance
  // test so anything it does is fine with us.
  vk::FALSE
}