Struct sfml_rust::vkprocessor::VkProcessor

pub struct VkProcessor<'a> {
    pub instance: Arc<Instance>,
    pub physical: PhysicalDevice<'a>,
    pub device: Arc<Device>,
    pub queues: QueuesIter,
    pub queue: Arc<Queue>,
    pub swapchain: Option<Arc<Swapchain<Window>>>,
    pub swapchain_images: Option<Vec<Arc<SwapchainImage<Window>>>>,
    // some fields omitted
}

VKProcessor holds the vulkan instance information, the swapchain, and the compute and canvas states

Fields

instance: Arc<Instance>

physical: PhysicalDevice<'a>

device: Arc<Device>

queues: QueuesIter

queue: Arc<Queue>

swapchain: Option<Arc<Swapchain<Window>>>

swapchain_images: Option<Vec<Arc<SwapchainImage<Window>>>>

Methods

impl<'a> VkProcessor<'a>

pub fn new(
    instance: &'a Arc<Instance>,
    surface: &'a Arc<Surface<Window>>
) -> VkProcessor<'a>

Creates a new VkProcessor from an instance and surface This includes the physical device, queues, compute and canvas state

pub fn is_open(&mut self) -> bool

VKProcessor controls the window. So it will let the main loop know when it is done

pub fn create_swapchain(&mut self, surface: &'a Arc<Surface<Window>>)

Using the surface, we calculate the surface capabilities and create the swapchain and swapchain images

pub fn recreate_swapchain(&mut self, surface: &'a Arc<Surface<Window>>)

On screen resizes, the swapchain and images must be recreated

pub fn preload_textures(&mut self)

A hardcoded list of textures which can be preloaded from this function

pub fn preload_kernels(&mut self)

A hardcoded list of kernels which can be preloaded from this function

pub fn preload_shaders(&mut self)

A hardcoded list of shaders which can be preloaded from this function

pub fn preload_fonts(&mut self)

A hardcoded list of shaders which can be proloaded from this function

pub fn get_texture_handle(
    &self,
    texture_name: String
) -> Option<Arc<CanvasTextureHandle>>

O(n) Lookup for the matching texture string

pub fn get_kernel_handle(
    &self,
    kernel_name: String
) -> Option<Arc<CompuKernelHandle>>

O(n) Lookup for the matching kernel string

pub fn get_shader_handle(
    &self,
    shader_name: String
) -> Option<Arc<CompiledShaderHandle>>

O(n) Lookup for the matching shader string

pub fn get_font_handle(
    &self,
    font_name: String
) -> Option<Arc<CanvasFontHandle>>

pub fn new_swap_image(
    &mut self,
    dimensions: (u32, u32)
) -> Arc<CanvasImageHandle>

Create a new image which has the transfer usage

pub fn new_compute_buffer(
    &mut self,
    data: Vec<u8>,
    dimensions: (u32, u32),
    stride: u32
) -> Arc<CompuBufferHandle>

Builds a compute buffer and returns it's handle

pub fn read_compute_buffer(&mut self, handle: Arc<CompuBufferHandle>) -> Vec<u8>

Takes a compute buffer handle and returns the read data

pub fn write_compute_buffer(
    &self,
    handle: Arc<CompuBufferHandle>,
    data: Vec<u8>
)

Takes a compute buffer handle and writes the received data

pub fn run(
    &mut self,
    surface: &'a Arc<Surface<Window>>,
    canvas_frame: CanvasFrame,
    compute_frame: CompuFrame
)

Run the VKprocessor for a single frame, consuming the Canvas/Compu Frames