gravitron 0.1.2

A GameEngine based on an ECS and Vulkan
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use anyhow::Error;
use gpu_allocator::vulkan;
use pipeline::PipelineManager;
use swap_chain::SwapChain;

use crate::config::{app::AppConfig, vulkan::VulkanConfig};

use super::{
  device::Device, error::RendererInitError, instance::InstanceDevice,
  surface::Surface,
};

mod pipeline;
mod swap_chain;

pub(crate) struct Renderer {
  render_pass: ash::vk::RenderPass,
  swap_chain: SwapChain,
  pipeline: PipelineManager,
}

impl Renderer {
  pub(crate) fn init(
    instance: &InstanceDevice,
    device: &Device,
    allocator: &mut vulkan::Allocator,
    surface: &Surface,
    config: &mut VulkanConfig,
    app_config: &AppConfig
  ) -> Result<Self, Error> {
    let format = surface
      .get_formats(instance.get_physical_device())?
      .first()
      .ok_or(RendererInitError::FormatMissing)?
      .format;
    let render_pass = pipeline::init_render_pass(device.get_device(), format)?;
    let mut swap_chain = SwapChain::init(
      instance.get_instance(),
      instance.get_physical_device(),
      device.get_device(),
      surface,
      device.get_queue_families(),
      allocator,
      app_config,
    )?;
    swap_chain.create_frame_buffers(device.get_device(), render_pass)?;
    let pipeline = PipelineManager::init(
      device.get_device(),
      render_pass,
      &swap_chain.get_extent(),
      &mut config.shaders,
    )?;

    Ok(Self {
      render_pass,
      swap_chain,
      pipeline,
    })
  }

  pub(crate) fn destroy(
    &mut self,
    logical_device: &ash::Device,
    allocator: &mut vulkan::Allocator,
  ) {
    self.pipeline.destroy(logical_device);
    self.swap_chain.destroy(logical_device, allocator);
    unsafe {
      logical_device.destroy_render_pass(self.render_pass, None);
    }
  }
}