Struct pilka_lib::PilkaRender

pub struct PilkaRender<'a> {

    pub paused: bool,
    pub descriptor_sets: Vec<DescriptorSet, Global>,
    pub descriptor_sets_compute: Vec<DescriptorSet, Global>,
    pub screenshot_ctx: ScreenshotCtx<'a>,
    pub push_constant: PushConstant,
    pub scissors: Box<[Rect2D], Global>,
    pub viewports: Box<[Viewport], Global>,
    pub extent: Extent2D,
    pub shader_set: HashMap<PathBuf, usize, RandomState>,
    pub compiler: Compiler,
    pub rendering_complete_semaphore: Semaphore,
    pub present_complete_semaphore: Semaphore,
    pub command_pool: VkCommandPool,
    pub command_pool_transfer: VkCommandPool,
    pub pipeline_cache: PipelineCache,
    pub pipelines: Vec<Pipeline, Global>,
    pub render_pass: VkRenderPass,
    pub framebuffers: Vec<Framebuffer, Global>,
    pub swapchain: VkSwapchain,
    pub surface: VkSurface,
    pub device_properties: VkDeviceProperties,
    pub queues: VkQueues,
    pub device: VkDevice,
    pub instance: VkInstance,
    // some fields omitted
}

The main struct that holds all render primitives

Rust documentation states for FIFO drop order for struct fields. Or in the other words it’s the same order that they’re declared.

Fields

paused: bool

descriptor_sets: Vec<DescriptorSet, Global>

descriptor_sets_compute: Vec<DescriptorSet, Global>

screenshot_ctx: ScreenshotCtx<'a>

push_constant: PushConstant

scissors: Box<[Rect2D], Global>

viewports: Box<[Viewport], Global>

extent: Extent2D

shader_set: HashMap<PathBuf, usize, RandomState>

compiler: Compiler

rendering_complete_semaphore: Semaphore

present_complete_semaphore: Semaphore

command_pool: VkCommandPool

command_pool_transfer: VkCommandPool

pipeline_cache: PipelineCache

pipelines: Vec<Pipeline, Global>

render_pass: VkRenderPass

framebuffers: Vec<Framebuffer, Global>

swapchain: VkSwapchain

surface: VkSurface

device_properties: VkDeviceProperties

queues: VkQueues

device: VkDevice

instance: VkInstance

Implementations

impl<'a> PilkaRender<'a>

pub fn get_device_name(&self) -> Result<&str, Utf8Error>

pub fn get_device_type(&self) -> PhysicalDeviceType

pub fn get_vendor_name(&self) -> &str

pub fn get_vulkan_version_name(&self) -> Result<String, Result>

pub fn new<W>(
    window: &W
) -> Result<PilkaRender<'a>, Box<dyn Error + 'static, Global>> where
    W: HasRawWindowHandle, 

pub fn render(&mut self) -> Result<(), Result>

pub fn resize(&mut self) -> Result<(), Result>

pub fn push_compute_pipeline(
    &mut self,
    comp_info: ShaderInfo,
    dependencies: &[PathBuf]
) -> Result<(), Result>

pub fn push_render_pipeline(
    &mut self,
    vert_info: ShaderInfo,
    frag_info: ShaderInfo,
    dependencies: &[PathBuf]
) -> Result<(), Result>

pub fn make_pipeline_from_shaders(
    &mut self,
    shader_set: &ShaderSet
) -> Result<Pipeline, Result>

pub fn new_graphics_pipeline(
    &self,
    pipeline_cache: PipelineCache,
    shader_set: Box<[PipelineShaderStageCreateInfo], Global>,
    vs_info: &ShaderInfo,
    fs_info: &ShaderInfo
) -> Result<VkGraphicsPipeline, Result>

pub fn new_compute_pipeline(
    &self,
    shader_set: PipelineShaderStageCreateInfo,
    cs_info: &ShaderInfo
) -> Result<VkComputePipeline, Result>

pub fn rebuild_pipeline(&mut self, index: usize) -> Result<(), Result>

pub fn create_graphics_pipeline_layout(
    &self
) -> Result<(PipelineLayout, Vec<DescriptorSetLayout, Global>), Result>

pub fn create_compute_pipeline_layout(
    &self
) -> Result<(PipelineLayout, Vec<DescriptorSetLayout, Global>), Result>

pub fn capture_frame(&mut self) -> Result<(&[u8], (u32, u32)), Result>

pub fn update_fft_texture(&mut self, data: &[f32]) -> Result<(), Result>

Trait Implementations

impl<'a> Drop for PilkaRender<'a>

pub fn drop(&mut self)

Executes the destructor for this type.