diff --git a/Cargo.toml b/Cargo.toml index fd21c49..fad3c19 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,3 +11,4 @@ cgmath = "0.17.0" image = "0.22" memoffset = "0.5.1" tobj = "0.1.10" +rand = "0.8.5" diff --git a/rec b/rec deleted file mode 100644 index 3e52a3f..0000000 --- a/rec +++ /dev/null @@ -1,801 +0,0 @@ -use crate::{ - shaders::*, entities::*, utility, utility::constants::*, utility::debug::*, utility::share, utility::structures::*, -}; - -use ash::{vk, Entry}; -use memoffset::offset_of; -use vk::*; -use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent}; -use winit::event_loop::{ControlFlow, EventLoop}; - -use std::ffi::CString; -use std::ptr; - -// Constants -const WINDOW_TITLE: &'static str = "Template"; - -pub struct VulkanApp { - window: winit::window::Window, - - // vulkan stuff - _entry: ash::Entry, - instance: ash::Instance, - surface_loader: ash::extensions::khr::Surface, - surface: vk::SurfaceKHR, - debug_utils_loader: ash::extensions::ext::DebugUtils, - debug_merssager: vk::DebugUtilsMessengerEXT, - - physical_device: vk::PhysicalDevice, - device: ash::Device, - - queue_family: QueueFamilyIndices, - graphics_queue: vk::Queue, - present_queue: vk::Queue, - - swapchain_loader: ash::extensions::khr::Swapchain, - swapchain: vk::SwapchainKHR, - swapchain_images: Vec, - swapchain_format: vk::Format, - swapchain_extent: vk::Extent2D, - swapchain_imageviews: Vec, - swapchain_framebuffers: Vec, - - render_pass: vk::RenderPass, - pipeline_layout: vk::PipelineLayout, - graphics_pipeline: vk::Pipeline, - - vertex_buffer: vk::Buffer, - vertex_buffer_memory: vk::DeviceMemory, - - command_pool: vk::CommandPool, - command_buffers: Vec, - - image_available_semaphores: Vec, - render_finished_semaphores: Vec, - in_flight_fences: Vec, - current_frame: usize, - - is_framebuffer_resized: bool, -} - -impl VulkanApp { - pub fn new(event_loop: &winit::event_loop::EventLoop<()>) -> VulkanApp { - let window = - utility::window::init_window(event_loop, WINDOW_TITLE, WINDOW_WIDTH, WINDOW_HEIGHT); - - // init vulkan stuff - let entry = unsafe { Entry::load().unwrap() }; - let instance = share::create_instance( - &entry, - WINDOW_TITLE, - VALIDATION.is_enable, - &VALIDATION.required_validation_layers.to_vec(), - ); - let surface_stuff = - share::create_surface(&entry, &instance, &window, WINDOW_WIDTH, WINDOW_HEIGHT); - let (debug_utils_loader, debug_merssager) = - setup_debug_utils(VALIDATION.is_enable, &entry, &instance); - let physical_device = - share::pick_physical_device(&instance, &surface_stuff, &DEVICE_EXTENSIONS); - let (device, queue_family) = share::create_logical_device( - &instance, - physical_device, - &VALIDATION, - &DEVICE_EXTENSIONS, - &surface_stuff, - ); - let graphics_queue = - unsafe { device.get_device_queue(queue_family.graphics_family.unwrap(), 0) }; - let present_queue = - unsafe { device.get_device_queue(queue_family.present_family.unwrap(), 0) }; - let swapchain_stuff = share::create_swapchain( - &instance, - &device, - physical_device, - &window, - &surface_stuff, - &queue_family, - ); - let swapchain_imageviews = share::v1::create_image_views( - &device, - swapchain_stuff.swapchain_format, - &swapchain_stuff.swapchain_images, - ); - let render_pass = share::v1::create_render_pass(&device, swapchain_stuff.swapchain_format); - let (graphics_pipeline, pipeline_layout) = VulkanApp::create_graphics_pipeline( - &device, - render_pass, - swapchain_stuff.swapchain_extent, - ); - let swapchain_framebuffers = share::v1::create_framebuffers( - &device, - render_pass, - &swapchain_imageviews, - swapchain_stuff.swapchain_extent, - ); - let command_pool = share::v1::create_command_pool(&device, &queue_family); - let (vertex_buffer, vertex_buffer_memory) = - VulkanApp::create_vertex_buffer(&instance, &device, physical_device); - let command_buffers = VulkanApp::create_command_buffers( - &device, - command_pool, - graphics_pipeline, - &swapchain_framebuffers, - render_pass, - swapchain_stuff.swapchain_extent, - vertex_buffer, - ); - let sync_ojbects = share::v1::create_sync_objects(&device, MAX_FRAMES_IN_FLIGHT); - - // cleanup(); the 'drop' function will take care of it. - VulkanApp { - // winit stuff - window, - - // vulkan stuff - _entry: entry, - instance, - surface: surface_stuff.surface, - surface_loader: surface_stuff.surface_loader, - debug_utils_loader, - debug_merssager, - - physical_device, - device, - - queue_family, - graphics_queue, - present_queue, - - swapchain_loader: swapchain_stuff.swapchain_loader, - swapchain: swapchain_stuff.swapchain, - swapchain_format: swapchain_stuff.swapchain_format, - swapchain_images: swapchain_stuff.swapchain_images, - swapchain_extent: swapchain_stuff.swapchain_extent, - swapchain_imageviews, - swapchain_framebuffers, - - pipeline_layout, - render_pass, - graphics_pipeline, - - vertex_buffer, - vertex_buffer_memory, - - command_pool, - command_buffers, - - image_available_semaphores: sync_ojbects.image_available_semaphores, - render_finished_semaphores: sync_ojbects.render_finished_semaphores, - in_flight_fences: sync_ojbects.inflight_fences, - current_frame: 0, - - is_framebuffer_resized: false, - } - } - - fn create_vertex_buffer( - instance: &ash::Instance, - device: &ash::Device, - physical_device: vk::PhysicalDevice, - ) -> (vk::Buffer, vk::DeviceMemory) { - let vertex_buffer_create_info = vk::BufferCreateInfo { - s_type: vk::StructureType::BUFFER_CREATE_INFO, - p_next: ptr::null(), - flags: vk::BufferCreateFlags::empty(), - size: std::mem::size_of_val(&TRI_VERT_DATA) as u64, - usage: vk::BufferUsageFlags::VERTEX_BUFFER - | vk::BufferUsageFlags::STORAGE_BUFFER - | vk::BufferUsageFlags::TRANSFER_DST, - sharing_mode: vk::SharingMode::EXCLUSIVE, - queue_family_index_count: 0, - p_queue_family_indices: ptr::null(), - }; - - let vertex_buffer = unsafe { - device - .create_buffer(&vertex_buffer_create_info, None) - .expect("Failed to create Vertex Buffer") - }; - - let mem_requirements = unsafe { device.get_buffer_memory_requirements(vertex_buffer) }; - let mem_properties = - unsafe { instance.get_physical_device_memory_properties(physical_device) }; - let required_memory_flags: vk::MemoryPropertyFlags = - vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT; - let memory_type = VulkanApp::find_memory_type( - mem_requirements.memory_type_bits, - required_memory_flags, - mem_properties, - ); - - let allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, - p_next: ptr::null(), - allocation_size: mem_requirements.size, - memory_type_index: memory_type, - }; - - let vertex_buffer_memory = unsafe { - device - .allocate_memory(&allocate_info, None) - .expect("Failed to allocate vertex buffer memory!") - }; - - unsafe { - device - .bind_buffer_memory(vertex_buffer, vertex_buffer_memory, 0) - .expect("Failed to bind Buffer"); - - let data_ptr = device - .map_memory( - vertex_buffer_memory, - 0, - vertex_buffer_create_info.size, - vk::MemoryMapFlags::empty(), - ) - .expect("Failed to Map Memory") as *mut Vertex; - - data_ptr.copy_from_nonoverlapping(TRI_VERT_DATA.as_ptr(), TRI_VERT_DATA.len()); - - device.unmap_memory(vertex_buffer_memory); - } - - (vertex_buffer, vertex_buffer_memory) - } - - fn find_memory_type( - type_filter: u32, - required_properties: vk::MemoryPropertyFlags, - mem_properties: vk::PhysicalDeviceMemoryProperties, - ) -> u32 { - for (i, memory_type) in mem_properties.memory_types.iter().enumerate() { - //if (type_filter & (1 << i)) > 0 && (memory_type.property_flags & required_properties) == required_properties { - // return i as u32 - // } - - // same implementation - if (type_filter & (1 << i)) > 0 - && memory_type.property_flags.contains(required_properties) - { - return i as u32; - } - } - - panic!("Failed to find suitable memory type!") - } - - fn create_command_buffers( - device: &ash::Device, - command_pool: vk::CommandPool, - graphics_pipeline: vk::Pipeline, - framebuffers: &Vec, - render_pass: vk::RenderPass, - surface_extent: vk::Extent2D, - vertex_buffer: vk::Buffer, - ) -> Vec { - let command_buffer_allocate_info = vk::CommandBufferAllocateInfo { - s_type: vk::StructureType::COMMAND_BUFFER_ALLOCATE_INFO, - p_next: ptr::null(), - command_buffer_count: framebuffers.len() as u32, - command_pool, - level: vk::CommandBufferLevel::PRIMARY, - }; - - let command_buffers = unsafe { - device - .allocate_command_buffers(&command_buffer_allocate_info) - .expect("Failed to allocate Command Buffers!") - }; - - for (i, &command_buffer) in command_buffers.iter().enumerate() { - let command_buffer_begin_info = vk::CommandBufferBeginInfo { - s_type: vk::StructureType::COMMAND_BUFFER_BEGIN_INFO, - p_next: ptr::null(), - flags: vk::CommandBufferUsageFlags::SIMULTANEOUS_USE, - p_inheritance_info: ptr::null(), - }; - - unsafe { - device - .begin_command_buffer(command_buffer, &command_buffer_begin_info) - .expect("Failed to begin recording Command Buffer at beginning!"); - } - - let clear_values = [vk::ClearValue { - color: vk::ClearColorValue { - float32: [0.0, 0.0, 0.0, 1.0], - }, - }]; - - let render_pass_begin_info = vk::RenderPassBeginInfo { - s_type: vk::StructureType::RENDER_PASS_BEGIN_INFO, - p_next: ptr::null(), - framebuffer: framebuffers[i], - render_pass, - clear_value_count: clear_values.len() as u32, - p_clear_values: clear_values.as_ptr(), - render_area: vk::Rect2D { - offset: vk::Offset2D { x: 0, y: 0 }, - extent: surface_extent, - }, - }; - - unsafe { - device.cmd_begin_render_pass( - command_buffer, - &render_pass_begin_info, - vk::SubpassContents::INLINE, - ); - device.cmd_bind_pipeline( - command_buffer, - vk::PipelineBindPoint::GRAPHICS, - graphics_pipeline, - ); - - let vertex_buffers = [vertex_buffer]; - let offsets = [0_u64]; - - device.cmd_bind_vertex_buffers(command_buffer, 0, &vertex_buffers, &offsets); - - device.cmd_draw(command_buffer, TRI_VERT_DATA.len() as u32, 1, 0, 0); - - device.cmd_end_render_pass(command_buffer); - - device - .end_command_buffer(command_buffer) - .expect("Failed to record Command Buffer at Ending!"); - } - } - - command_buffers - } -} - -// Fix content ------------------------------------------------------------------------------- -impl VulkanApp { - fn create_graphics_pipeline( - device: &ash::Device, - render_pass: vk::RenderPass, - swapchain_extent: vk::Extent2D, - ) -> (vk::Pipeline, vk::PipelineLayout) { - let mut shader_modules: Vec = vec![]; - let main_function = CString::new("main").unwrap(); - for (shader, stage_i) in shaders() { - shader_modules.push( - vk::PipelineShaderStageCreateInfo { - s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::PipelineShaderStageCreateFlags::empty(), - module: share::create_shader_module(device, shader), - p_name: main_function.as_ptr(), - stage: stage_i, - p_specialization_info: ptr::null(), - - } - ) - } - - let binding_description = Vertex::get_binding_description(); - let attribute_description = Vertex::get_attribute_descriptions(); - - let vertex_input_state_create_info = vk::PipelineVertexInputStateCreateInfo { - s_type: vk::StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::PipelineVertexInputStateCreateFlags::empty(), - vertex_attribute_description_count: attribute_description.len() as u32, - p_vertex_attribute_descriptions: attribute_description.as_ptr(), - vertex_binding_description_count: binding_description.len() as u32, - p_vertex_binding_descriptions: binding_description.as_ptr(), - }; - let vertex_input_assembly_state_info = vk::PipelineInputAssemblyStateCreateInfo { - s_type: vk::StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - flags: vk::PipelineInputAssemblyStateCreateFlags::empty(), - p_next: ptr::null(), - topology: vk::PrimitiveTopology::TRIANGLE_LIST, - primitive_restart_enable: vk::FALSE, - }; - - let viewports = [vk::Viewport { - x: 0.0, - y: 0.0, - width: swapchain_extent.width as f32, - height: swapchain_extent.height as f32, - min_depth: 0.0, - max_depth: 1.0, - }]; - - let scissors = [vk::Rect2D { - offset: vk::Offset2D { x: 0, y: 0 }, - extent: swapchain_extent, - }]; - - let viewport_state_create_info = vk::PipelineViewportStateCreateInfo { - s_type: vk::StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::PipelineViewportStateCreateFlags::empty(), - scissor_count: scissors.len() as u32, - p_scissors: scissors.as_ptr(), - viewport_count: viewports.len() as u32, - p_viewports: viewports.as_ptr(), - }; - - let rasterization_statue_create_info = vk::PipelineRasterizationStateCreateInfo { - s_type: vk::StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::PipelineRasterizationStateCreateFlags::empty(), - cull_mode: vk::CullModeFlags::BACK, - front_face: vk::FrontFace::CLOCKWISE, - line_width: 1.0, - polygon_mode: vk::PolygonMode::FILL, - rasterizer_discard_enable: vk::FALSE, - depth_clamp_enable: vk::FALSE, - depth_bias_clamp: 0.0, - depth_bias_constant_factor: 0.0, - depth_bias_enable: vk::FALSE, - depth_bias_slope_factor: 0.0, - }; - - let multisample_state_create_info = vk::PipelineMultisampleStateCreateInfo { - s_type: vk::StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, - flags: vk::PipelineMultisampleStateCreateFlags::empty(), - p_next: ptr::null(), - rasterization_samples: vk::SampleCountFlags::TYPE_1, - sample_shading_enable: vk::FALSE, - min_sample_shading: 0.0, - p_sample_mask: ptr::null(), - alpha_to_one_enable: vk::FALSE, - alpha_to_coverage_enable: vk::FALSE, - }; - - let stencil_state = vk::StencilOpState { - fail_op: vk::StencilOp::KEEP, - pass_op: vk::StencilOp::KEEP, - depth_fail_op: vk::StencilOp::KEEP, - compare_op: vk::CompareOp::ALWAYS, - compare_mask: 0, - write_mask: 0, - reference: 0, - }; - - let depth_state_create_info = vk::PipelineDepthStencilStateCreateInfo { - s_type: vk::StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::PipelineDepthStencilStateCreateFlags::empty(), - depth_test_enable: vk::FALSE, - depth_write_enable: vk::FALSE, - depth_compare_op: vk::CompareOp::LESS_OR_EQUAL, - depth_bounds_test_enable: vk::FALSE, - stencil_test_enable: vk::FALSE, - front: stencil_state, - back: stencil_state, - max_depth_bounds: 1.0, - min_depth_bounds: 0.0, - }; - - let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState { - blend_enable: vk::FALSE, - color_write_mask: vk::ColorComponentFlags::RGBA, - src_color_blend_factor: vk::BlendFactor::ONE, - dst_color_blend_factor: vk::BlendFactor::ZERO, - color_blend_op: vk::BlendOp::ADD, - src_alpha_blend_factor: vk::BlendFactor::ONE, - dst_alpha_blend_factor: vk::BlendFactor::ZERO, - alpha_blend_op: vk::BlendOp::ADD, - }]; - - let color_blend_state = vk::PipelineColorBlendStateCreateInfo { - s_type: vk::StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::PipelineColorBlendStateCreateFlags::empty(), - logic_op_enable: vk::FALSE, - logic_op: vk::LogicOp::COPY, - attachment_count: color_blend_attachment_states.len() as u32, - p_attachments: color_blend_attachment_states.as_ptr(), - blend_constants: [0.0, 0.0, 0.0, 0.0], - }; - - let pipeline_layout_create_info = vk::PipelineLayoutCreateInfo { - s_type: vk::StructureType::PIPELINE_LAYOUT_CREATE_INFO, - p_next: ptr::null(), - flags: vk::PipelineLayoutCreateFlags::empty(), - set_layout_count: 0, - p_set_layouts: ptr::null(), - push_constant_range_count: 0, - p_push_constant_ranges: ptr::null(), - }; - - let pipeline_layout = unsafe { - device - .create_pipeline_layout(&pipeline_layout_create_info, None) - .expect("Failed to create pipeline layout!") - }; - - let graphic_pipeline_create_infos = [vk::GraphicsPipelineCreateInfo { - s_type: vk::StructureType::GRAPHICS_PIPELINE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::PipelineCreateFlags::empty(), - stage_count: shader_modules.len() as u32, - p_stages: shader_modules.as_ptr(), - p_vertex_input_state: &vertex_input_state_create_info, - p_input_assembly_state: &vertex_input_assembly_state_info, - p_tessellation_state: ptr::null(), - p_viewport_state: &viewport_state_create_info, - p_rasterization_state: &rasterization_statue_create_info, - p_multisample_state: &multisample_state_create_info, - p_depth_stencil_state: &depth_state_create_info, - p_color_blend_state: &color_blend_state, - p_dynamic_state: ptr::null(), - layout: pipeline_layout, - render_pass, - subpass: 0, - base_pipeline_handle: vk::Pipeline::null(), - base_pipeline_index: -1, - }]; - - let graphics_pipelines = unsafe { - device - .create_graphics_pipelines( - vk::PipelineCache::null(), - &graphic_pipeline_create_infos, - None, - ) - .expect("Failed to create Graphics Pipeline!.") - }; - - unsafe { - for shader in shader_modules { - device.destroy_shader_module(shader.module, None) - } - } - - (graphics_pipelines[0], pipeline_layout) - } - - fn draw_frame(&mut self) { - let wait_fences = [self.in_flight_fences[self.current_frame]]; - - unsafe { - self.device - .wait_for_fences(&wait_fences, true, std::u64::MAX) - .expect("Failed to wait for Fence!"); - } - - let (image_index, _is_sub_optimal) = unsafe { - let result = self.swapchain_loader.acquire_next_image( - self.swapchain, - std::u64::MAX, - self.image_available_semaphores[self.current_frame], - vk::Fence::null(), - ); - match result { - Ok(image_index) => image_index, - Err(vk_result) => match vk_result { - vk::Result::ERROR_OUT_OF_DATE_KHR => { - self.recreate_swapchain(); - return; - } - _ => panic!("Failed to acquire Swap Chain Image!"), - }, - } - }; - - let wait_semaphores = [self.image_available_semaphores[self.current_frame]]; - let wait_stages = [vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT]; - let signal_semaphores = [self.render_finished_semaphores[self.current_frame]]; - - let submit_infos = [vk::SubmitInfo { - s_type: vk::StructureType::SUBMIT_INFO, - p_next: ptr::null(), - wait_semaphore_count: wait_semaphores.len() as u32, - p_wait_semaphores: wait_semaphores.as_ptr(), - p_wait_dst_stage_mask: wait_stages.as_ptr(), - command_buffer_count: 1, - p_command_buffers: &self.command_buffers[image_index as usize], - signal_semaphore_count: signal_semaphores.len() as u32, - p_signal_semaphores: signal_semaphores.as_ptr(), - }]; - - unsafe { - self.device - .reset_fences(&wait_fences) - .expect("Failed to reset Fence!"); - - self.device - .queue_submit( - self.graphics_queue, - &submit_infos, - self.in_flight_fences[self.current_frame], - ) - .expect("Failed to execute queue submit."); - } - - let swapchains = [self.swapchain]; - - let present_info = vk::PresentInfoKHR { - s_type: vk::StructureType::PRESENT_INFO_KHR, - p_next: ptr::null(), - wait_semaphore_count: 1, - p_wait_semaphores: signal_semaphores.as_ptr(), - swapchain_count: 1, - p_swapchains: swapchains.as_ptr(), - p_image_indices: &image_index, - p_results: ptr::null_mut(), - }; - - let result = unsafe { - self.swapchain_loader - .queue_present(self.present_queue, &present_info) - }; - - let is_resized = match result { - Ok(_) => self.is_framebuffer_resized, - Err(vk_result) => match vk_result { - vk::Result::ERROR_OUT_OF_DATE_KHR | vk::Result::SUBOPTIMAL_KHR => true, - _ => panic!("Failed to execute queue present."), - }, - }; - if is_resized { - self.is_framebuffer_resized = false; - self.recreate_swapchain(); - } - - self.current_frame = (self.current_frame + 1) % MAX_FRAMES_IN_FLIGHT; - } - - fn recreate_swapchain(&mut self) { - // parameters ------------- - let surface_suff = SurfaceStuff { - surface_loader: self.surface_loader.clone(), - surface: self.surface, - screen_width: WINDOW_WIDTH, - screen_height: WINDOW_HEIGHT, - }; - // ------------------------ - - unsafe { - self.device - .device_wait_idle() - .expect("Failed to wait device idle!") - }; - self.cleanup_swapchain(); - - let swapchain_stuff = share::create_swapchain( - &self.instance, - &self.device, - self.physical_device, - &self.window, - &surface_suff, - &self.queue_family, - ); - self.swapchain_loader = swapchain_stuff.swapchain_loader; - self.swapchain = swapchain_stuff.swapchain; - self.swapchain_images = swapchain_stuff.swapchain_images; - self.swapchain_format = swapchain_stuff.swapchain_format; - self.swapchain_extent = swapchain_stuff.swapchain_extent; - - self.swapchain_imageviews = share::v1::create_image_views( - &self.device, - self.swapchain_format, - &self.swapchain_images, - ); - self.render_pass = share::v1::create_render_pass(&self.device, self.swapchain_format); - let (graphics_pipeline, pipeline_layout) = VulkanApp::create_graphics_pipeline( - &self.device, - self.render_pass, - swapchain_stuff.swapchain_extent, - ); - self.graphics_pipeline = graphics_pipeline; - self.pipeline_layout = pipeline_layout; - - self.swapchain_framebuffers = share::v1::create_framebuffers( - &self.device, - self.render_pass, - &self.swapchain_imageviews, - self.swapchain_extent, - ); - self.command_buffers = VulkanApp::create_command_buffers( - &self.device, - self.command_pool, - self.graphics_pipeline, - &self.swapchain_framebuffers, - self.render_pass, - self.swapchain_extent, - self.vertex_buffer, - ); - } - - fn cleanup_swapchain(&self) { - unsafe { - self.device - .free_command_buffers(self.command_pool, &self.command_buffers); - for &framebuffer in self.swapchain_framebuffers.iter() { - self.device.destroy_framebuffer(framebuffer, None); - } - self.device.destroy_pipeline(self.graphics_pipeline, None); - self.device - .destroy_pipeline_layout(self.pipeline_layout, None); - self.device.destroy_render_pass(self.render_pass, None); - for &image_view in self.swapchain_imageviews.iter() { - self.device.destroy_image_view(image_view, None); - } - self.swapchain_loader - .destroy_swapchain(self.swapchain, None); - } - } -} - -impl Drop for VulkanApp { - fn drop(&mut self) { - unsafe { - for i in 0..MAX_FRAMES_IN_FLIGHT { - self.device - .destroy_semaphore(self.image_available_semaphores[i], None); - self.device - .destroy_semaphore(self.render_finished_semaphores[i], None); - self.device.destroy_fence(self.in_flight_fences[i], None); - } - - self.cleanup_swapchain(); - - self.device.destroy_buffer(self.vertex_buffer, None); - self.device.free_memory(self.vertex_buffer_memory, None); - - self.device.destroy_command_pool(self.command_pool, None); - - self.device.destroy_device(None); - self.surface_loader.destroy_surface(self.surface, None); - - if VALIDATION.is_enable { - self.debug_utils_loader - .destroy_debug_utils_messenger(self.debug_merssager, None); - } - self.instance.destroy_instance(None); - } - } -} - -impl VulkanApp { - pub fn main_loop(mut self, event_loop: EventLoop<()>) { - let mut tick_counter = utility::fps_limiter::FPSLimiter::new(); - - event_loop.run(move |event, _, control_flow| match event { - Event::WindowEvent { event, .. } => match event { - WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit, - WindowEvent::KeyboardInput { input, .. } => match input { - KeyboardInput { - virtual_keycode, - state, - .. - } => match (virtual_keycode, state) { - (Some(VirtualKeyCode::Escape), ElementState::Pressed) => { - *control_flow = ControlFlow::Exit - } - _ => {} - }, - }, - _ => {} - }, - Event::MainEventsCleared => { - self.window.request_redraw(); - } - Event::RedrawRequested(_window_id) => { - self.draw_frame(); - - tick_counter.tick_frame(); - if true { - print!("FPS: {}\r", tick_counter.fps()); - } - } - Event::LoopDestroyed => { - unsafe { - self.device - .device_wait_idle() - .expect("Failed to wait device idle!") - }; - } - _ => (), - }) - } -} - diff --git a/src/entities.rs b/src/entities.rs index bb27118..a04a89c 100644 --- a/src/entities.rs +++ b/src/entities.rs @@ -1,16 +1,43 @@ use memoffset::offset_of; use ash::vk; +use rand::{thread_rng, distributions::{Distribution, Uniform}}; +use cgmath::{InnerSpace, Vector2, Vector4}; +use num::traits::FloatConst; +use crate::utility::constants::*; +use std::f32::consts::PI; + +const PARTICLE_COUNT: i32 = 1000; #[repr(C)] #[derive(Clone, Debug, Copy)] pub struct Particle { - pos: [f32; 2], - vel: [f32; 4], - color: [f32; 4], + pos: Vector2, + vel: Vector2, + color: Vector4, } impl Particle { + pub fn gen() -> Vec { + let mut res = vec![]; + + let between = Uniform::from(0.0..1.0); + let mut rng = thread_rng(); + for i in 0..PARTICLE_COUNT { + let r = (between.sample(&mut rng) as f32).sqrt(); + let theta = between.sample(&mut rng) * 2.0 * PI; + let x = r * theta.cos() * WINDOW_HEIGHT as f32 * WINDOW_WIDTH as f32; + let y = r * theta.sin(); + res.push( + Particle { + pos: Vector2::new(x, y), + vel: Vector2::new(x, y).normalize() * 0.00025, + color: Vector4::new(between.sample(&mut rng), between.sample(&mut rng), between.sample(&mut rng), 1.0), + } + ) + } + res + } } #[repr(C)] diff --git a/src/render.rs b/src/render.rs index 3e52a3f..e6d2f9b 100644 --- a/src/render.rs +++ b/src/render.rs @@ -1,5 +1,5 @@ use crate::{ - shaders::*, entities::*, utility, utility::constants::*, utility::debug::*, utility::share, utility::structures::*, + shaders::*, entities::*, utility, utility::constants::*, utility::debug::*, utility::share, utility::share::*, utility::structures::*, }; use ash::{vk, Entry}; @@ -96,24 +96,24 @@ impl VulkanApp { &surface_stuff, &queue_family, ); - let swapchain_imageviews = share::v1::create_image_views( + let swapchain_imageviews = share::create_image_views( &device, swapchain_stuff.swapchain_format, &swapchain_stuff.swapchain_images, ); - let render_pass = share::v1::create_render_pass(&device, swapchain_stuff.swapchain_format); + let render_pass = share::create_render_pass(&device, swapchain_stuff.swapchain_format); let (graphics_pipeline, pipeline_layout) = VulkanApp::create_graphics_pipeline( &device, render_pass, swapchain_stuff.swapchain_extent, ); - let swapchain_framebuffers = share::v1::create_framebuffers( + let swapchain_framebuffers = share::create_framebuffers( &device, render_pass, &swapchain_imageviews, swapchain_stuff.swapchain_extent, ); - let command_pool = share::v1::create_command_pool(&device, &queue_family); + let command_pool = share::create_command_pool(&device, &queue_family); let (vertex_buffer, vertex_buffer_memory) = VulkanApp::create_vertex_buffer(&instance, &device, physical_device); let command_buffers = VulkanApp::create_command_buffers( @@ -125,7 +125,7 @@ impl VulkanApp { swapchain_stuff.swapchain_extent, vertex_buffer, ); - let sync_ojbects = share::v1::create_sync_objects(&device, MAX_FRAMES_IN_FLIGHT); + let sync_ojbects = share::create_sync_objects(&device, MAX_FRAMES_IN_FLIGHT); // cleanup(); the 'drop' function will take care of it. VulkanApp { @@ -674,12 +674,12 @@ impl VulkanApp { self.swapchain_format = swapchain_stuff.swapchain_format; self.swapchain_extent = swapchain_stuff.swapchain_extent; - self.swapchain_imageviews = share::v1::create_image_views( + self.swapchain_imageviews = share::create_image_views( &self.device, self.swapchain_format, &self.swapchain_images, ); - self.render_pass = share::v1::create_render_pass(&self.device, self.swapchain_format); + self.render_pass = share::create_render_pass(&self.device, self.swapchain_format); let (graphics_pipeline, pipeline_layout) = VulkanApp::create_graphics_pipeline( &self.device, self.render_pass, @@ -688,7 +688,7 @@ impl VulkanApp { self.graphics_pipeline = graphics_pipeline; self.pipeline_layout = pipeline_layout; - self.swapchain_framebuffers = share::v1::create_framebuffers( + self.swapchain_framebuffers = share::create_framebuffers( &self.device, self.render_pass, &self.swapchain_imageviews, diff --git a/src/utility/share.rs b/src/utility/share.rs index e7a72e7..dfbb9de 100644 --- a/src/utility/share.rs +++ b/src/utility/share.rs @@ -1,995 +1,919 @@ -pub mod v1 { - use ash::vk; - use image; - use image::GenericImageView; - - use std::cmp::max; - use std::ffi::CString; - use std::path::Path; - use std::ptr; - - use super::*; - - pub fn create_render_pass(device: &ash::Device, surface_format: vk::Format) -> vk::RenderPass { - let color_attachment = vk::AttachmentDescription { - format: surface_format, - flags: vk::AttachmentDescriptionFlags::empty(), - samples: vk::SampleCountFlags::TYPE_1, - load_op: vk::AttachmentLoadOp::CLEAR, - store_op: vk::AttachmentStoreOp::STORE, - stencil_load_op: vk::AttachmentLoadOp::DONT_CARE, - stencil_store_op: vk::AttachmentStoreOp::DONT_CARE, - initial_layout: vk::ImageLayout::UNDEFINED, - final_layout: vk::ImageLayout::PRESENT_SRC_KHR, - }; - - let color_attachment_ref = vk::AttachmentReference { - attachment: 0, - layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL, - }; - - let subpasses = [vk::SubpassDescription { - color_attachment_count: 1, - p_color_attachments: &color_attachment_ref, - p_depth_stencil_attachment: ptr::null(), - flags: vk::SubpassDescriptionFlags::empty(), - pipeline_bind_point: vk::PipelineBindPoint::GRAPHICS, - input_attachment_count: 0, - p_input_attachments: ptr::null(), - p_resolve_attachments: ptr::null(), - preserve_attachment_count: 0, - p_preserve_attachments: ptr::null(), - }]; +use ash::vk; +use image; +use image::GenericImageView; - let render_pass_attachments = [color_attachment]; +use std::cmp::max; +use std::ffi::CString; +use std::path::Path; +use std::ptr; +use std::os::raw::{c_char, c_void}; +use crate::utility::constants::*; +use crate::utility::{debug, platforms}; +use crate::utility::structures::*; - let subpass_dependencies = [vk::SubpassDependency { - src_subpass: vk::SUBPASS_EXTERNAL, - dst_subpass: 0, - src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, - dst_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, - src_access_mask: vk::AccessFlags::empty(), - dst_access_mask: vk::AccessFlags::COLOR_ATTACHMENT_WRITE, - dependency_flags: vk::DependencyFlags::empty(), - }]; +use super::*; + +pub fn create_render_pass(device: &ash::Device, surface_format: vk::Format) -> vk::RenderPass { + let color_attachment = vk::AttachmentDescription { + format: surface_format, + flags: vk::AttachmentDescriptionFlags::empty(), + samples: vk::SampleCountFlags::TYPE_1, + load_op: vk::AttachmentLoadOp::CLEAR, + store_op: vk::AttachmentStoreOp::STORE, + stencil_load_op: vk::AttachmentLoadOp::DONT_CARE, + stencil_store_op: vk::AttachmentStoreOp::DONT_CARE, + initial_layout: vk::ImageLayout::UNDEFINED, + final_layout: vk::ImageLayout::PRESENT_SRC_KHR, + }; - let renderpass_create_info = vk::RenderPassCreateInfo { - s_type: vk::StructureType::RENDER_PASS_CREATE_INFO, - flags: vk::RenderPassCreateFlags::empty(), - p_next: ptr::null(), - attachment_count: render_pass_attachments.len() as u32, - p_attachments: render_pass_attachments.as_ptr(), - subpass_count: subpasses.len() as u32, - p_subpasses: subpasses.as_ptr(), - dependency_count: subpass_dependencies.len() as u32, - p_dependencies: subpass_dependencies.as_ptr(), - }; + let color_attachment_ref = vk::AttachmentReference { + attachment: 0, + layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL, + }; - unsafe { - device - .create_render_pass(&renderpass_create_info, None) - .expect("Failed to create render pass!") - } - } + let subpasses = [vk::SubpassDescription { + color_attachment_count: 1, + p_color_attachments: &color_attachment_ref, + p_depth_stencil_attachment: ptr::null(), + flags: vk::SubpassDescriptionFlags::empty(), + pipeline_bind_point: vk::PipelineBindPoint::GRAPHICS, + input_attachment_count: 0, + p_input_attachments: ptr::null(), + p_resolve_attachments: ptr::null(), + preserve_attachment_count: 0, + p_preserve_attachments: ptr::null(), + }]; - pub fn create_framebuffers( - device: &ash::Device, - render_pass: vk::RenderPass, - image_views: &Vec, - swapchain_extent: vk::Extent2D, - ) -> Vec { - let mut framebuffers = vec![]; - - for &image_view in image_views.iter() { - let attachments = [image_view]; - - let framebuffer_create_info = vk::FramebufferCreateInfo { - s_type: vk::StructureType::FRAMEBUFFER_CREATE_INFO, - p_next: ptr::null(), - flags: vk::FramebufferCreateFlags::empty(), - render_pass, - attachment_count: attachments.len() as u32, - p_attachments: attachments.as_ptr(), - width: swapchain_extent.width, - height: swapchain_extent.height, - layers: 1, - }; + let render_pass_attachments = [color_attachment]; - let framebuffer = unsafe { - device - .create_framebuffer(&framebuffer_create_info, None) - .expect("Failed to create Framebuffer!") - }; + let subpass_dependencies = [vk::SubpassDependency { + src_subpass: vk::SUBPASS_EXTERNAL, + dst_subpass: 0, + src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, + dst_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, + src_access_mask: vk::AccessFlags::empty(), + dst_access_mask: vk::AccessFlags::COLOR_ATTACHMENT_WRITE, + dependency_flags: vk::DependencyFlags::empty(), + }]; - framebuffers.push(framebuffer); - } + let renderpass_create_info = vk::RenderPassCreateInfo { + s_type: vk::StructureType::RENDER_PASS_CREATE_INFO, + flags: vk::RenderPassCreateFlags::empty(), + p_next: ptr::null(), + attachment_count: render_pass_attachments.len() as u32, + p_attachments: render_pass_attachments.as_ptr(), + subpass_count: subpasses.len() as u32, + p_subpasses: subpasses.as_ptr(), + dependency_count: subpass_dependencies.len() as u32, + p_dependencies: subpass_dependencies.as_ptr(), + }; - framebuffers + unsafe { + device + .create_render_pass(&renderpass_create_info, None) + .expect("Failed to create render pass!") } +} - pub fn create_command_pool( - device: &ash::Device, - queue_families: &QueueFamilyIndices, - ) -> vk::CommandPool { - let command_pool_create_info = vk::CommandPoolCreateInfo { - s_type: vk::StructureType::COMMAND_POOL_CREATE_INFO, - p_next: ptr::null(), - flags: vk::CommandPoolCreateFlags::empty(), - queue_family_index: queue_families.graphics_family.unwrap(), - }; +pub fn create_framebuffers( + device: &ash::Device, + render_pass: vk::RenderPass, + image_views: &Vec, + swapchain_extent: vk::Extent2D, +) -> Vec { + let mut framebuffers = vec![]; - unsafe { - device - .create_command_pool(&command_pool_create_info, None) - .expect("Failed to create Command Pool!") - } - } + for &image_view in image_views.iter() { + let attachments = [image_view]; - pub fn create_command_buffers( - device: &ash::Device, - command_pool: vk::CommandPool, - graphics_pipeline: vk::Pipeline, - framebuffers: &Vec, - render_pass: vk::RenderPass, - surface_extent: vk::Extent2D, - ) -> Vec { - let command_buffer_allocate_info = vk::CommandBufferAllocateInfo { - s_type: vk::StructureType::COMMAND_BUFFER_ALLOCATE_INFO, + let framebuffer_create_info = vk::FramebufferCreateInfo { + s_type: vk::StructureType::FRAMEBUFFER_CREATE_INFO, p_next: ptr::null(), - command_buffer_count: framebuffers.len() as u32, - command_pool, - level: vk::CommandBufferLevel::PRIMARY, + flags: vk::FramebufferCreateFlags::empty(), + render_pass, + attachment_count: attachments.len() as u32, + p_attachments: attachments.as_ptr(), + width: swapchain_extent.width, + height: swapchain_extent.height, + layers: 1, }; - let command_buffers = unsafe { + let framebuffer = unsafe { device - .allocate_command_buffers(&command_buffer_allocate_info) - .expect("Failed to allocate Command Buffers!") + .create_framebuffer(&framebuffer_create_info, None) + .expect("Failed to create Framebuffer!") }; - for (i, &command_buffer) in command_buffers.iter().enumerate() { - let command_buffer_begin_info = vk::CommandBufferBeginInfo { - s_type: vk::StructureType::COMMAND_BUFFER_BEGIN_INFO, - p_next: ptr::null(), - p_inheritance_info: ptr::null(), - flags: vk::CommandBufferUsageFlags::SIMULTANEOUS_USE, - }; - - unsafe { - device - .begin_command_buffer(command_buffer, &command_buffer_begin_info) - .expect("Failed to begin recording Command Buffer at beginning!"); - } + framebuffers.push(framebuffer); + } - let clear_values = [vk::ClearValue { - color: vk::ClearColorValue { - float32: [0.0, 0.0, 0.0, 1.0], - }, - }]; - - let render_pass_begin_info = vk::RenderPassBeginInfo { - s_type: vk::StructureType::RENDER_PASS_BEGIN_INFO, - p_next: ptr::null(), - render_pass, - framebuffer: framebuffers[i], - render_area: vk::Rect2D { - offset: vk::Offset2D { x: 0, y: 0 }, - extent: surface_extent, - }, - clear_value_count: clear_values.len() as u32, - p_clear_values: clear_values.as_ptr(), - }; + framebuffers +} - unsafe { - device.cmd_begin_render_pass( - command_buffer, - &render_pass_begin_info, - vk::SubpassContents::INLINE, - ); - device.cmd_bind_pipeline( - command_buffer, - vk::PipelineBindPoint::GRAPHICS, - graphics_pipeline, - ); - device.cmd_draw(command_buffer, 3, 1, 0, 0); - - device.cmd_end_render_pass(command_buffer); - - device - .end_command_buffer(command_buffer) - .expect("Failed to record Command Buffer at Ending!"); - } - } +pub fn create_command_pool( + device: &ash::Device, + queue_families: &QueueFamilyIndices, +) -> vk::CommandPool { + let command_pool_create_info = vk::CommandPoolCreateInfo { + s_type: vk::StructureType::COMMAND_POOL_CREATE_INFO, + p_next: ptr::null(), + flags: vk::CommandPoolCreateFlags::empty(), + queue_family_index: queue_families.graphics_family.unwrap(), + }; - command_buffers + unsafe { + device + .create_command_pool(&command_pool_create_info, None) + .expect("Failed to create Command Pool!") } +} - pub fn create_sync_objects(device: &ash::Device, max_frame_in_flight: usize) -> SyncObjects { - let mut sync_objects = SyncObjects { - image_available_semaphores: vec![], - render_finished_semaphores: vec![], - inflight_fences: vec![], - }; +pub fn create_command_buffers( + device: &ash::Device, + command_pool: vk::CommandPool, + graphics_pipeline: vk::Pipeline, + framebuffers: &Vec, + render_pass: vk::RenderPass, + surface_extent: vk::Extent2D, +) -> Vec { + let command_buffer_allocate_info = vk::CommandBufferAllocateInfo { + s_type: vk::StructureType::COMMAND_BUFFER_ALLOCATE_INFO, + p_next: ptr::null(), + command_buffer_count: framebuffers.len() as u32, + command_pool, + level: vk::CommandBufferLevel::PRIMARY, + }; - let semaphore_create_info = vk::SemaphoreCreateInfo { - s_type: vk::StructureType::SEMAPHORE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::SemaphoreCreateFlags::empty(), - }; + let command_buffers = unsafe { + device + .allocate_command_buffers(&command_buffer_allocate_info) + .expect("Failed to allocate Command Buffers!") + }; - let fence_create_info = vk::FenceCreateInfo { - s_type: vk::StructureType::FENCE_CREATE_INFO, + for (i, &command_buffer) in command_buffers.iter().enumerate() { + let command_buffer_begin_info = vk::CommandBufferBeginInfo { + s_type: vk::StructureType::COMMAND_BUFFER_BEGIN_INFO, p_next: ptr::null(), - flags: vk::FenceCreateFlags::SIGNALED, + p_inheritance_info: ptr::null(), + flags: vk::CommandBufferUsageFlags::SIMULTANEOUS_USE, }; - for _ in 0..max_frame_in_flight { - unsafe { - let image_available_semaphore = device - .create_semaphore(&semaphore_create_info, None) - .expect("Failed to create Semaphore Object!"); - let render_finished_semaphore = device - .create_semaphore(&semaphore_create_info, None) - .expect("Failed to create Semaphore Object!"); - let inflight_fence = device - .create_fence(&fence_create_info, None) - .expect("Failed to create Fence Object!"); - - sync_objects - .image_available_semaphores - .push(image_available_semaphore); - sync_objects - .render_finished_semaphores - .push(render_finished_semaphore); - sync_objects.inflight_fences.push(inflight_fence); - } + unsafe { + device + .begin_command_buffer(command_buffer, &command_buffer_begin_info) + .expect("Failed to begin recording Command Buffer at beginning!"); } - sync_objects - } - - pub fn create_vertex_buffer( - device: &ash::Device, - device_memory_properties: &vk::PhysicalDeviceMemoryProperties, - command_pool: vk::CommandPool, - submit_queue: vk::Queue, - data: &[T], - ) -> (vk::Buffer, vk::DeviceMemory) { - let buffer_size = ::std::mem::size_of_val(data) as vk::DeviceSize; + let clear_values = [vk::ClearValue { + color: vk::ClearColorValue { + float32: [0.0, 0.0, 0.0, 1.0], + }, + }]; - let (staging_buffer, staging_buffer_memory) = create_buffer( - device, - buffer_size, - vk::BufferUsageFlags::TRANSFER_SRC, - vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT, - &device_memory_properties, - ); + let render_pass_begin_info = vk::RenderPassBeginInfo { + s_type: vk::StructureType::RENDER_PASS_BEGIN_INFO, + p_next: ptr::null(), + render_pass, + framebuffer: framebuffers[i], + render_area: vk::Rect2D { + offset: vk::Offset2D { x: 0, y: 0 }, + extent: surface_extent, + }, + clear_value_count: clear_values.len() as u32, + p_clear_values: clear_values.as_ptr(), + }; unsafe { - let data_ptr = device - .map_memory( - staging_buffer_memory, - 0, - buffer_size, - vk::MemoryMapFlags::empty(), - ) - .expect("Failed to Map Memory") as *mut T; + device.cmd_begin_render_pass( + command_buffer, + &render_pass_begin_info, + vk::SubpassContents::INLINE, + ); + device.cmd_bind_pipeline( + command_buffer, + vk::PipelineBindPoint::GRAPHICS, + graphics_pipeline, + ); + device.cmd_draw(command_buffer, 3, 1, 0, 0); - data_ptr.copy_from_nonoverlapping(data.as_ptr(), data.len()); + device.cmd_end_render_pass(command_buffer); - device.unmap_memory(staging_buffer_memory); + device + .end_command_buffer(command_buffer) + .expect("Failed to record Command Buffer at Ending!"); } + } - let (vertex_buffer, vertex_buffer_memory) = create_buffer( - device, - buffer_size, - vk::BufferUsageFlags::TRANSFER_DST | vk::BufferUsageFlags::VERTEX_BUFFER, - vk::MemoryPropertyFlags::DEVICE_LOCAL, - &device_memory_properties, - ); + command_buffers +} - copy_buffer( - device, - submit_queue, - command_pool, - staging_buffer, - vertex_buffer, - buffer_size, - ); +pub fn create_sync_objects(device: &ash::Device, max_frame_in_flight: usize) -> SyncObjects { + let mut sync_objects = SyncObjects { + image_available_semaphores: vec![], + render_finished_semaphores: vec![], + inflight_fences: vec![], + }; + + let semaphore_create_info = vk::SemaphoreCreateInfo { + s_type: vk::StructureType::SEMAPHORE_CREATE_INFO, + p_next: ptr::null(), + flags: vk::SemaphoreCreateFlags::empty(), + }; + + let fence_create_info = vk::FenceCreateInfo { + s_type: vk::StructureType::FENCE_CREATE_INFO, + p_next: ptr::null(), + flags: vk::FenceCreateFlags::SIGNALED, + }; + for _ in 0..max_frame_in_flight { unsafe { - device.destroy_buffer(staging_buffer, None); - device.free_memory(staging_buffer_memory, None); + let image_available_semaphore = device + .create_semaphore(&semaphore_create_info, None) + .expect("Failed to create Semaphore Object!"); + let render_finished_semaphore = device + .create_semaphore(&semaphore_create_info, None) + .expect("Failed to create Semaphore Object!"); + let inflight_fence = device + .create_fence(&fence_create_info, None) + .expect("Failed to create Fence Object!"); + + sync_objects + .image_available_semaphores + .push(image_available_semaphore); + sync_objects + .render_finished_semaphores + .push(render_finished_semaphore); + sync_objects.inflight_fences.push(inflight_fence); } - - (vertex_buffer, vertex_buffer_memory) } - pub fn create_index_buffer( - device: &ash::Device, - device_memory_properties: &vk::PhysicalDeviceMemoryProperties, - command_pool: vk::CommandPool, - submit_queue: vk::Queue, - data: &[u32], - ) -> (vk::Buffer, vk::DeviceMemory) { - let buffer_size = ::std::mem::size_of_val(data) as vk::DeviceSize; + sync_objects +} - let (staging_buffer, staging_buffer_memory) = create_buffer( - device, - buffer_size, - vk::BufferUsageFlags::TRANSFER_SRC, - vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT, - &device_memory_properties, - ); +pub fn create_vertex_buffer( + device: &ash::Device, + device_memory_properties: &vk::PhysicalDeviceMemoryProperties, + command_pool: vk::CommandPool, + submit_queue: vk::Queue, + data: &[T], +) -> (vk::Buffer, vk::DeviceMemory) { + let buffer_size = ::std::mem::size_of_val(data) as vk::DeviceSize; + + let (staging_buffer, staging_buffer_memory) = create_buffer( + device, + buffer_size, + vk::BufferUsageFlags::TRANSFER_SRC, + vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT, + &device_memory_properties, + ); - unsafe { - let data_ptr = device - .map_memory( - staging_buffer_memory, - 0, - buffer_size, - vk::MemoryMapFlags::empty(), - ) - .expect("Failed to Map Memory") as *mut u32; + unsafe { + let data_ptr = device + .map_memory( + staging_buffer_memory, + 0, + buffer_size, + vk::MemoryMapFlags::empty(), + ) + .expect("Failed to Map Memory") as *mut T; - data_ptr.copy_from_nonoverlapping(data.as_ptr(), data.len()); + data_ptr.copy_from_nonoverlapping(data.as_ptr(), data.len()); - device.unmap_memory(staging_buffer_memory); - } + device.unmap_memory(staging_buffer_memory); + } - let (index_buffer, index_buffer_memory) = create_buffer( - device, - buffer_size, - vk::BufferUsageFlags::TRANSFER_DST | vk::BufferUsageFlags::INDEX_BUFFER, - vk::MemoryPropertyFlags::DEVICE_LOCAL, - &device_memory_properties, - ); + let (vertex_buffer, vertex_buffer_memory) = create_buffer( + device, + buffer_size, + vk::BufferUsageFlags::TRANSFER_DST | vk::BufferUsageFlags::VERTEX_BUFFER, + vk::MemoryPropertyFlags::DEVICE_LOCAL, + &device_memory_properties, + ); - copy_buffer( - device, - submit_queue, - command_pool, - staging_buffer, - index_buffer, - buffer_size, - ); + copy_buffer( + device, + submit_queue, + command_pool, + staging_buffer, + vertex_buffer, + buffer_size, + ); - unsafe { - device.destroy_buffer(staging_buffer, None); - device.free_memory(staging_buffer_memory, None); - } + unsafe { + device.destroy_buffer(staging_buffer, None); + device.free_memory(staging_buffer_memory, None); + } + + (vertex_buffer, vertex_buffer_memory) +} + +pub fn create_descriptor_pool( + device: &ash::Device, + swapchain_images_size: usize, +) -> vk::DescriptorPool { + let pool_sizes = [vk::DescriptorPoolSize { + ty: vk::DescriptorType::UNIFORM_BUFFER, + descriptor_count: swapchain_images_size as u32, + }]; + + let descriptor_pool_create_info = vk::DescriptorPoolCreateInfo { + s_type: vk::StructureType::DESCRIPTOR_POOL_CREATE_INFO, + p_next: ptr::null(), + flags: vk::DescriptorPoolCreateFlags::empty(), + max_sets: swapchain_images_size as u32, + pool_size_count: pool_sizes.len() as u32, + p_pool_sizes: pool_sizes.as_ptr(), + }; - (index_buffer, index_buffer_memory) + unsafe { + device + .create_descriptor_pool(&descriptor_pool_create_info, None) + .expect("Failed to create Descriptor Pool!") + } +} + +pub fn create_descriptor_sets( + device: &ash::Device, + descriptor_pool: vk::DescriptorPool, + descriptor_set_layout: vk::DescriptorSetLayout, + uniforms_buffers: &Vec, + swapchain_images_size: usize, +) -> Vec { + let mut layouts: Vec = vec![]; + for _ in 0..swapchain_images_size { + layouts.push(descriptor_set_layout); } - pub fn create_descriptor_pool( - device: &ash::Device, - swapchain_images_size: usize, - ) -> vk::DescriptorPool { - let pool_sizes = [vk::DescriptorPoolSize { - ty: vk::DescriptorType::UNIFORM_BUFFER, - descriptor_count: swapchain_images_size as u32, + let descriptor_set_allocate_info = vk::DescriptorSetAllocateInfo { + s_type: vk::StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, + p_next: ptr::null(), + descriptor_pool, + descriptor_set_count: swapchain_images_size as u32, + p_set_layouts: layouts.as_ptr(), + }; + + let descriptor_sets = unsafe { + device + .allocate_descriptor_sets(&descriptor_set_allocate_info) + .expect("Failed to allocate descriptor sets!") + }; + + for (i, &descritptor_set) in descriptor_sets.iter().enumerate() { + let descriptor_buffer_info = [vk::DescriptorBufferInfo { + buffer: uniforms_buffers[i], + offset: 0, + range: ::std::mem::size_of::() as u64, }]; - let descriptor_pool_create_info = vk::DescriptorPoolCreateInfo { - s_type: vk::StructureType::DESCRIPTOR_POOL_CREATE_INFO, + let descriptor_write_sets = [vk::WriteDescriptorSet { + s_type: vk::StructureType::WRITE_DESCRIPTOR_SET, p_next: ptr::null(), - flags: vk::DescriptorPoolCreateFlags::empty(), - max_sets: swapchain_images_size as u32, - pool_size_count: pool_sizes.len() as u32, - p_pool_sizes: pool_sizes.as_ptr(), - }; + dst_set: descritptor_set, + dst_binding: 0, + dst_array_element: 0, + descriptor_count: 1, + descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, + p_image_info: ptr::null(), + p_buffer_info: descriptor_buffer_info.as_ptr(), + p_texel_buffer_view: ptr::null(), + }]; unsafe { - device - .create_descriptor_pool(&descriptor_pool_create_info, None) - .expect("Failed to create Descriptor Pool!") + device.update_descriptor_sets(&descriptor_write_sets, &[]); } } - pub fn create_descriptor_sets( - device: &ash::Device, - descriptor_pool: vk::DescriptorPool, - descriptor_set_layout: vk::DescriptorSetLayout, - uniforms_buffers: &Vec, - swapchain_images_size: usize, - ) -> Vec { - let mut layouts: Vec = vec![]; - for _ in 0..swapchain_images_size { - layouts.push(descriptor_set_layout); - } - - let descriptor_set_allocate_info = vk::DescriptorSetAllocateInfo { - s_type: vk::StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, - p_next: ptr::null(), - descriptor_pool, - descriptor_set_count: swapchain_images_size as u32, - p_set_layouts: layouts.as_ptr(), - }; + descriptor_sets +} - let descriptor_sets = unsafe { - device - .allocate_descriptor_sets(&descriptor_set_allocate_info) - .expect("Failed to allocate descriptor sets!") - }; +pub fn create_descriptor_set_layout(device: &ash::Device) -> vk::DescriptorSetLayout { + let ubo_layout_bindings = [vk::DescriptorSetLayoutBinding { + binding: 0, + descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, + descriptor_count: 1, + stage_flags: vk::ShaderStageFlags::VERTEX, + p_immutable_samplers: ptr::null(), + }]; - for (i, &descritptor_set) in descriptor_sets.iter().enumerate() { - let descriptor_buffer_info = [vk::DescriptorBufferInfo { - buffer: uniforms_buffers[i], - offset: 0, - range: ::std::mem::size_of::() as u64, - }]; - - let descriptor_write_sets = [vk::WriteDescriptorSet { - s_type: vk::StructureType::WRITE_DESCRIPTOR_SET, - p_next: ptr::null(), - dst_set: descritptor_set, - dst_binding: 0, - dst_array_element: 0, - descriptor_count: 1, - descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, - p_image_info: ptr::null(), - p_buffer_info: descriptor_buffer_info.as_ptr(), - p_texel_buffer_view: ptr::null(), - }]; - - unsafe { - device.update_descriptor_sets(&descriptor_write_sets, &[]); - } - } + let ubo_layout_create_info = vk::DescriptorSetLayoutCreateInfo { + s_type: vk::StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + p_next: ptr::null(), + flags: vk::DescriptorSetLayoutCreateFlags::empty(), + binding_count: ubo_layout_bindings.len() as u32, + p_bindings: ubo_layout_bindings.as_ptr(), + }; - descriptor_sets + unsafe { + device + .create_descriptor_set_layout(&ubo_layout_create_info, None) + .expect("Failed to create Descriptor Set Layout!") } +} - pub fn create_descriptor_set_layout(device: &ash::Device) -> vk::DescriptorSetLayout { - let ubo_layout_bindings = [vk::DescriptorSetLayoutBinding { - binding: 0, - descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, - descriptor_count: 1, - stage_flags: vk::ShaderStageFlags::VERTEX, - p_immutable_samplers: ptr::null(), - }]; +pub fn create_uniform_buffers( + device: &ash::Device, + device_memory_properties: &vk::PhysicalDeviceMemoryProperties, + swapchain_image_count: usize, +) -> (Vec, Vec) { + let buffer_size = ::std::mem::size_of::(); - let ubo_layout_create_info = vk::DescriptorSetLayoutCreateInfo { - s_type: vk::StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - p_next: ptr::null(), - flags: vk::DescriptorSetLayoutCreateFlags::empty(), - binding_count: ubo_layout_bindings.len() as u32, - p_bindings: ubo_layout_bindings.as_ptr(), - }; + let mut uniform_buffers = vec![]; + let mut uniform_buffers_memory = vec![]; - unsafe { - device - .create_descriptor_set_layout(&ubo_layout_create_info, None) - .expect("Failed to create Descriptor Set Layout!") - } + for _ in 0..swapchain_image_count { + let (uniform_buffer, uniform_buffer_memory) = create_buffer( + device, + buffer_size as u64, + vk::BufferUsageFlags::UNIFORM_BUFFER, + vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT, + device_memory_properties, + ); + uniform_buffers.push(uniform_buffer); + uniform_buffers_memory.push(uniform_buffer_memory); } - pub fn create_uniform_buffers( - device: &ash::Device, - device_memory_properties: &vk::PhysicalDeviceMemoryProperties, - swapchain_image_count: usize, - ) -> (Vec, Vec) { - let buffer_size = ::std::mem::size_of::(); + (uniform_buffers, uniform_buffers_memory) +} + +pub fn create_image( + device: &ash::Device, + width: u32, + height: u32, + mip_levels: u32, + num_samples: vk::SampleCountFlags, + format: vk::Format, + tiling: vk::ImageTiling, + usage: vk::ImageUsageFlags, + required_memory_properties: vk::MemoryPropertyFlags, + device_memory_properties: &vk::PhysicalDeviceMemoryProperties, +) -> (vk::Image, vk::DeviceMemory) { + let image_create_info = vk::ImageCreateInfo { + s_type: vk::StructureType::IMAGE_CREATE_INFO, + p_next: ptr::null(), + flags: vk::ImageCreateFlags::empty(), + image_type: vk::ImageType::TYPE_2D, + format, + mip_levels, + array_layers: 1, + samples: num_samples, + tiling, + usage, + sharing_mode: vk::SharingMode::EXCLUSIVE, + queue_family_index_count: 0, + p_queue_family_indices: ptr::null(), + initial_layout: vk::ImageLayout::UNDEFINED, + extent: vk::Extent3D { + width, + height, + depth: 1, + }, + }; - let mut uniform_buffers = vec![]; - let mut uniform_buffers_memory = vec![]; + let texture_image = unsafe { + device + .create_image(&image_create_info, None) + .expect("Failed to create Texture Image!") + }; - for _ in 0..swapchain_image_count { - let (uniform_buffer, uniform_buffer_memory) = create_buffer( - device, - buffer_size as u64, - vk::BufferUsageFlags::UNIFORM_BUFFER, - vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT, - device_memory_properties, - ); - uniform_buffers.push(uniform_buffer); - uniform_buffers_memory.push(uniform_buffer_memory); - } + let image_memory_requirement = + unsafe { device.get_image_memory_requirements(texture_image) }; + let memory_allocate_info = vk::MemoryAllocateInfo { + s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, + p_next: ptr::null(), + allocation_size: image_memory_requirement.size, + memory_type_index: find_memory_type( + image_memory_requirement.memory_type_bits, + required_memory_properties, + device_memory_properties, + ), + }; - (uniform_buffers, uniform_buffers_memory) + let texture_image_memory = unsafe { + device + .allocate_memory(&memory_allocate_info, None) + .expect("Failed to allocate Texture Image memory!") + }; + + unsafe { + device + .bind_image_memory(texture_image, texture_image_memory, 0) + .expect("Failed to bind Image Memmory!"); } - pub fn create_image( - device: &ash::Device, - width: u32, - height: u32, - mip_levels: u32, - num_samples: vk::SampleCountFlags, - format: vk::Format, - tiling: vk::ImageTiling, - usage: vk::ImageUsageFlags, - required_memory_properties: vk::MemoryPropertyFlags, - device_memory_properties: &vk::PhysicalDeviceMemoryProperties, - ) -> (vk::Image, vk::DeviceMemory) { - let image_create_info = vk::ImageCreateInfo { - s_type: vk::StructureType::IMAGE_CREATE_INFO, - p_next: ptr::null(), - flags: vk::ImageCreateFlags::empty(), - image_type: vk::ImageType::TYPE_2D, - format, - mip_levels, - array_layers: 1, - samples: num_samples, - tiling, - usage, - sharing_mode: vk::SharingMode::EXCLUSIVE, - queue_family_index_count: 0, - p_queue_family_indices: ptr::null(), - initial_layout: vk::ImageLayout::UNDEFINED, - extent: vk::Extent3D { - width, - height, - depth: 1, - }, - }; + (texture_image, texture_image_memory) +} - let texture_image = unsafe { - device - .create_image(&image_create_info, None) - .expect("Failed to create Texture Image!") - }; +pub fn transition_image_layout( + device: &ash::Device, + command_pool: vk::CommandPool, + submit_queue: vk::Queue, + image: vk::Image, + _format: vk::Format, + old_layout: vk::ImageLayout, + new_layout: vk::ImageLayout, + mip_levels: u32, +) { + let command_buffer = begin_single_time_command(device, command_pool); - let image_memory_requirement = - unsafe { device.get_image_memory_requirements(texture_image) }; - let memory_allocate_info = vk::MemoryAllocateInfo { - s_type: vk::StructureType::MEMORY_ALLOCATE_INFO, - p_next: ptr::null(), - allocation_size: image_memory_requirement.size, - memory_type_index: find_memory_type( - image_memory_requirement.memory_type_bits, - required_memory_properties, - device_memory_properties, - ), - }; + let src_access_mask; + let dst_access_mask; + let source_stage; + let destination_stage; - let texture_image_memory = unsafe { - device - .allocate_memory(&memory_allocate_info, None) - .expect("Failed to allocate Texture Image memory!") - }; + if old_layout == vk::ImageLayout::UNDEFINED + && new_layout == vk::ImageLayout::TRANSFER_DST_OPTIMAL + { + src_access_mask = vk::AccessFlags::empty(); + dst_access_mask = vk::AccessFlags::TRANSFER_WRITE; + source_stage = vk::PipelineStageFlags::TOP_OF_PIPE; + destination_stage = vk::PipelineStageFlags::TRANSFER; + } else if old_layout == vk::ImageLayout::TRANSFER_DST_OPTIMAL + && new_layout == vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL + { + src_access_mask = vk::AccessFlags::TRANSFER_WRITE; + dst_access_mask = vk::AccessFlags::SHADER_READ; + source_stage = vk::PipelineStageFlags::TRANSFER; + destination_stage = vk::PipelineStageFlags::FRAGMENT_SHADER; + } else if old_layout == vk::ImageLayout::UNDEFINED + && new_layout == vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL + { + src_access_mask = vk::AccessFlags::empty(); + dst_access_mask = + vk::AccessFlags::COLOR_ATTACHMENT_READ | vk::AccessFlags::COLOR_ATTACHMENT_WRITE; + source_stage = vk::PipelineStageFlags::TOP_OF_PIPE; + destination_stage = vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT; + } else { + panic!("Unsupported layout transition!") + } - unsafe { - device - .bind_image_memory(texture_image, texture_image_memory, 0) - .expect("Failed to bind Image Memmory!"); - } + let image_barriers = [vk::ImageMemoryBarrier { + s_type: vk::StructureType::IMAGE_MEMORY_BARRIER, + p_next: ptr::null(), + src_access_mask, + dst_access_mask, + old_layout, + new_layout, + src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + image, + subresource_range: vk::ImageSubresourceRange { + aspect_mask: vk::ImageAspectFlags::COLOR, + base_mip_level: 0, + level_count: mip_levels, + base_array_layer: 0, + layer_count: 1, + }, + }]; - (texture_image, texture_image_memory) + unsafe { + device.cmd_pipeline_barrier( + command_buffer, + source_stage, + destination_stage, + vk::DependencyFlags::empty(), + &[], + &[], + &image_barriers, + ); } - pub fn transition_image_layout( - device: &ash::Device, - command_pool: vk::CommandPool, - submit_queue: vk::Queue, - image: vk::Image, - _format: vk::Format, - old_layout: vk::ImageLayout, - new_layout: vk::ImageLayout, - mip_levels: u32, - ) { - let command_buffer = begin_single_time_command(device, command_pool); - - let src_access_mask; - let dst_access_mask; - let source_stage; - let destination_stage; - - if old_layout == vk::ImageLayout::UNDEFINED - && new_layout == vk::ImageLayout::TRANSFER_DST_OPTIMAL - { - src_access_mask = vk::AccessFlags::empty(); - dst_access_mask = vk::AccessFlags::TRANSFER_WRITE; - source_stage = vk::PipelineStageFlags::TOP_OF_PIPE; - destination_stage = vk::PipelineStageFlags::TRANSFER; - } else if old_layout == vk::ImageLayout::TRANSFER_DST_OPTIMAL - && new_layout == vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL - { - src_access_mask = vk::AccessFlags::TRANSFER_WRITE; - dst_access_mask = vk::AccessFlags::SHADER_READ; - source_stage = vk::PipelineStageFlags::TRANSFER; - destination_stage = vk::PipelineStageFlags::FRAGMENT_SHADER; - } else if old_layout == vk::ImageLayout::UNDEFINED - && new_layout == vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL - { - src_access_mask = vk::AccessFlags::empty(); - dst_access_mask = - vk::AccessFlags::COLOR_ATTACHMENT_READ | vk::AccessFlags::COLOR_ATTACHMENT_WRITE; - source_stage = vk::PipelineStageFlags::TOP_OF_PIPE; - destination_stage = vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT; - } else { - panic!("Unsupported layout transition!") - } + end_single_time_command(device, command_pool, submit_queue, command_buffer); +} - let image_barriers = [vk::ImageMemoryBarrier { - s_type: vk::StructureType::IMAGE_MEMORY_BARRIER, - p_next: ptr::null(), - src_access_mask, - dst_access_mask, - old_layout, - new_layout, - src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, - image, - subresource_range: vk::ImageSubresourceRange { - aspect_mask: vk::ImageAspectFlags::COLOR, - base_mip_level: 0, - level_count: mip_levels, - base_array_layer: 0, - layer_count: 1, - }, - }]; +pub fn create_image_views( + device: &ash::Device, + surface_format: vk::Format, + images: &Vec, +) -> Vec { + let swapchain_imageviews: Vec = images + .iter() + .map(|&image| { + create_image_view( + device, + image, + surface_format, + vk::ImageAspectFlags::COLOR, + 1, + ) + }) + .collect(); - unsafe { - device.cmd_pipeline_barrier( - command_buffer, - source_stage, - destination_stage, - vk::DependencyFlags::empty(), - &[], - &[], - &image_barriers, - ); - } + swapchain_imageviews +} + +pub fn create_image_view( + device: &ash::Device, + image: vk::Image, + format: vk::Format, + aspect_flags: vk::ImageAspectFlags, + mip_levels: u32, +) -> vk::ImageView { + let imageview_create_info = vk::ImageViewCreateInfo { + s_type: vk::StructureType::IMAGE_VIEW_CREATE_INFO, + p_next: ptr::null(), + flags: vk::ImageViewCreateFlags::empty(), + view_type: vk::ImageViewType::TYPE_2D, + format, + components: vk::ComponentMapping { + r: vk::ComponentSwizzle::IDENTITY, + g: vk::ComponentSwizzle::IDENTITY, + b: vk::ComponentSwizzle::IDENTITY, + a: vk::ComponentSwizzle::IDENTITY, + }, + subresource_range: vk::ImageSubresourceRange { + aspect_mask: aspect_flags, + base_mip_level: 0, + level_count: mip_levels, + base_array_layer: 0, + layer_count: 1, + }, + image, + }; - end_single_time_command(device, command_pool, submit_queue, command_buffer); + unsafe { + device + .create_image_view(&imageview_create_info, None) + .expect("Failed to create Image View!") } +} - pub fn create_image_views( - device: &ash::Device, - surface_format: vk::Format, - images: &Vec, - ) -> Vec { - let swapchain_imageviews: Vec = images - .iter() - .map(|&image| { - create_image_view( - device, - image, - surface_format, - vk::ImageAspectFlags::COLOR, - 1, - ) - }) - .collect(); +pub fn create_texture_image_view( + device: &ash::Device, + texture_image: vk::Image, + mip_levels: u32, +) -> vk::ImageView { + create_image_view( + device, + texture_image, + vk::Format::R8G8B8A8_SRGB, + vk::ImageAspectFlags::COLOR, + mip_levels, + ) +} - swapchain_imageviews +pub fn create_texture_sampler(device: &ash::Device) -> vk::Sampler { + let sampler_create_info = vk::SamplerCreateInfo { + s_type: vk::StructureType::SAMPLER_CREATE_INFO, + p_next: ptr::null(), + flags: vk::SamplerCreateFlags::empty(), + mag_filter: vk::Filter::LINEAR, + min_filter: vk::Filter::LINEAR, + address_mode_u: vk::SamplerAddressMode::REPEAT, + address_mode_v: vk::SamplerAddressMode::REPEAT, + address_mode_w: vk::SamplerAddressMode::REPEAT, + max_anisotropy: 16.0, + compare_enable: vk::FALSE, + compare_op: vk::CompareOp::ALWAYS, + mipmap_mode: vk::SamplerMipmapMode::LINEAR, + min_lod: 0.0, + max_lod: 0.0, + mip_lod_bias: 0.0, + border_color: vk::BorderColor::INT_OPAQUE_BLACK, + anisotropy_enable: vk::TRUE, + unnormalized_coordinates: vk::FALSE, + }; + + unsafe { + device + .create_sampler(&sampler_create_info, None) + .expect("Failed to create Sampler!") } +} - pub fn create_image_view( - device: &ash::Device, - image: vk::Image, - format: vk::Format, - aspect_flags: vk::ImageAspectFlags, - mip_levels: u32, - ) -> vk::ImageView { - let imageview_create_info = vk::ImageViewCreateInfo { - s_type: vk::StructureType::IMAGE_VIEW_CREATE_INFO, - p_next: ptr::null(), - flags: vk::ImageViewCreateFlags::empty(), - view_type: vk::ImageViewType::TYPE_2D, - format, - components: vk::ComponentMapping { - r: vk::ComponentSwizzle::IDENTITY, - g: vk::ComponentSwizzle::IDENTITY, - b: vk::ComponentSwizzle::IDENTITY, - a: vk::ComponentSwizzle::IDENTITY, - }, - subresource_range: vk::ImageSubresourceRange { - aspect_mask: aspect_flags, - base_mip_level: 0, - level_count: mip_levels, - base_array_layer: 0, - layer_count: 1, - }, - image, - }; +pub fn create_texture_image( + device: &ash::Device, + command_pool: vk::CommandPool, + submit_queue: vk::Queue, + device_memory_properties: &vk::PhysicalDeviceMemoryProperties, + image_path: &Path, +) -> (vk::Image, vk::DeviceMemory) { + let mut image_object = image::open(image_path).unwrap(); // this function is slow in debug mode. + image_object = image_object.flipv(); + let (image_width, image_height) = (image_object.width(), image_object.height()); + let image_data = match &image_object { + image::DynamicImage::ImageBgr8(_) + | image::DynamicImage::ImageLuma8(_) + | image::DynamicImage::ImageRgb8(_) => image_object.to_rgba().into_raw(), + image::DynamicImage::ImageBgra8(_) + | image::DynamicImage::ImageLumaA8(_) + | image::DynamicImage::ImageRgba8(_) => image_object.raw_pixels(), + }; + let image_size = + (::std::mem::size_of::() as u32 * image_width * image_height * 4) as vk::DeviceSize; - unsafe { - device - .create_image_view(&imageview_create_info, None) - .expect("Failed to create Image View!") - } + if image_size <= 0 { + panic!("Failed to load texture image!") } - pub fn create_texture_image_view( - device: &ash::Device, - texture_image: vk::Image, - mip_levels: u32, - ) -> vk::ImageView { - create_image_view( - device, - texture_image, - vk::Format::R8G8B8A8_SRGB, - vk::ImageAspectFlags::COLOR, - mip_levels, - ) - } + let (staging_buffer, staging_buffer_memory) = create_buffer( + device, + image_size, + vk::BufferUsageFlags::TRANSFER_SRC, + vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT, + device_memory_properties, + ); - pub fn create_texture_sampler(device: &ash::Device) -> vk::Sampler { - let sampler_create_info = vk::SamplerCreateInfo { - s_type: vk::StructureType::SAMPLER_CREATE_INFO, - p_next: ptr::null(), - flags: vk::SamplerCreateFlags::empty(), - mag_filter: vk::Filter::LINEAR, - min_filter: vk::Filter::LINEAR, - address_mode_u: vk::SamplerAddressMode::REPEAT, - address_mode_v: vk::SamplerAddressMode::REPEAT, - address_mode_w: vk::SamplerAddressMode::REPEAT, - max_anisotropy: 16.0, - compare_enable: vk::FALSE, - compare_op: vk::CompareOp::ALWAYS, - mipmap_mode: vk::SamplerMipmapMode::LINEAR, - min_lod: 0.0, - max_lod: 0.0, - mip_lod_bias: 0.0, - border_color: vk::BorderColor::INT_OPAQUE_BLACK, - anisotropy_enable: vk::TRUE, - unnormalized_coordinates: vk::FALSE, - }; + unsafe { + let data_ptr = device + .map_memory( + staging_buffer_memory, + 0, + image_size, + vk::MemoryMapFlags::empty(), + ) + .expect("Failed to Map Memory") as *mut u8; - unsafe { - device - .create_sampler(&sampler_create_info, None) - .expect("Failed to create Sampler!") - } - } + data_ptr.copy_from_nonoverlapping(image_data.as_ptr(), image_data.len()); - pub fn create_texture_image( - device: &ash::Device, - command_pool: vk::CommandPool, - submit_queue: vk::Queue, - device_memory_properties: &vk::PhysicalDeviceMemoryProperties, - image_path: &Path, - ) -> (vk::Image, vk::DeviceMemory) { - let mut image_object = image::open(image_path).unwrap(); // this function is slow in debug mode. - image_object = image_object.flipv(); - let (image_width, image_height) = (image_object.width(), image_object.height()); - let image_data = match &image_object { - image::DynamicImage::ImageBgr8(_) - | image::DynamicImage::ImageLuma8(_) - | image::DynamicImage::ImageRgb8(_) => image_object.to_rgba().into_raw(), - image::DynamicImage::ImageBgra8(_) - | image::DynamicImage::ImageLumaA8(_) - | image::DynamicImage::ImageRgba8(_) => image_object.raw_pixels(), - }; - let image_size = - (::std::mem::size_of::() as u32 * image_width * image_height * 4) as vk::DeviceSize; + device.unmap_memory(staging_buffer_memory); + } - if image_size <= 0 { - panic!("Failed to load texture image!") - } + let (texture_image, texture_image_memory) = create_image( + device, + image_width, + image_height, + 1, + vk::SampleCountFlags::TYPE_1, + vk::Format::R8G8B8A8_SRGB, + vk::ImageTiling::OPTIMAL, + vk::ImageUsageFlags::TRANSFER_DST | vk::ImageUsageFlags::SAMPLED, + vk::MemoryPropertyFlags::DEVICE_LOCAL, + device_memory_properties, + ); - let (staging_buffer, staging_buffer_memory) = create_buffer( - device, - image_size, - vk::BufferUsageFlags::TRANSFER_SRC, - vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT, - device_memory_properties, - ); + transition_image_layout( + device, + command_pool, + submit_queue, + texture_image, + vk::Format::R8G8B8A8_SRGB, + vk::ImageLayout::UNDEFINED, + vk::ImageLayout::TRANSFER_DST_OPTIMAL, + 1, + ); - unsafe { - let data_ptr = device - .map_memory( - staging_buffer_memory, - 0, - image_size, - vk::MemoryMapFlags::empty(), - ) - .expect("Failed to Map Memory") as *mut u8; + copy_buffer_to_image( + device, + command_pool, + submit_queue, + staging_buffer, + texture_image, + image_width, + image_height, + ); - data_ptr.copy_from_nonoverlapping(image_data.as_ptr(), image_data.len()); + transition_image_layout( + device, + command_pool, + submit_queue, + texture_image, + vk::Format::R8G8B8A8_UNORM, + vk::ImageLayout::TRANSFER_DST_OPTIMAL, + vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL, + 1, + ); - device.unmap_memory(staging_buffer_memory); - } + unsafe { + device.destroy_buffer(staging_buffer, None); + device.free_memory(staging_buffer_memory, None); + } - let (texture_image, texture_image_memory) = create_image( - device, - image_width, - image_height, - 1, - vk::SampleCountFlags::TYPE_1, - vk::Format::R8G8B8A8_SRGB, - vk::ImageTiling::OPTIMAL, - vk::ImageUsageFlags::TRANSFER_DST | vk::ImageUsageFlags::SAMPLED, - vk::MemoryPropertyFlags::DEVICE_LOCAL, - device_memory_properties, - ); + (texture_image, texture_image_memory) +} - transition_image_layout( - device, - command_pool, - submit_queue, - texture_image, - vk::Format::R8G8B8A8_SRGB, - vk::ImageLayout::UNDEFINED, - vk::ImageLayout::TRANSFER_DST_OPTIMAL, - 1, - ); +pub fn create_depth_resources( + instance: &ash::Instance, + device: &ash::Device, + physical_device: vk::PhysicalDevice, + _command_pool: vk::CommandPool, + _submit_queue: vk::Queue, + swapchain_extent: vk::Extent2D, + device_memory_properties: &vk::PhysicalDeviceMemoryProperties, + msaa_samples: vk::SampleCountFlags, +) -> (vk::Image, vk::ImageView, vk::DeviceMemory) { + let depth_format = find_depth_format(instance, physical_device); + let (depth_image, depth_image_memory) = create_image( + device, + swapchain_extent.width, + swapchain_extent.height, + 1, + msaa_samples, + depth_format, + vk::ImageTiling::OPTIMAL, + vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT, + vk::MemoryPropertyFlags::DEVICE_LOCAL, + device_memory_properties, + ); + let depth_image_view = create_image_view( + device, + depth_image, + depth_format, + vk::ImageAspectFlags::DEPTH, + 1, + ); - copy_buffer_to_image( - device, - command_pool, - submit_queue, - staging_buffer, - texture_image, - image_width, - image_height, - ); + (depth_image, depth_image_view, depth_image_memory) +} - transition_image_layout( - device, - command_pool, - submit_queue, - texture_image, - vk::Format::R8G8B8A8_UNORM, - vk::ImageLayout::TRANSFER_DST_OPTIMAL, - vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL, - 1, - ); +pub fn generate_mipmaps( + device: &ash::Device, + command_pool: vk::CommandPool, + submit_queue: vk::Queue, + image: vk::Image, + tex_width: u32, + tex_height: u32, + mip_levels: u32, +) { + let command_buffer = begin_single_time_command(device, command_pool); - unsafe { - device.destroy_buffer(staging_buffer, None); - device.free_memory(staging_buffer_memory, None); - } + let mut image_barrier = vk::ImageMemoryBarrier { + s_type: vk::StructureType::IMAGE_MEMORY_BARRIER, + p_next: ptr::null(), + src_access_mask: vk::AccessFlags::empty(), + dst_access_mask: vk::AccessFlags::empty(), + old_layout: vk::ImageLayout::UNDEFINED, + new_layout: vk::ImageLayout::UNDEFINED, + src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, + image, + subresource_range: vk::ImageSubresourceRange { + aspect_mask: vk::ImageAspectFlags::COLOR, + base_mip_level: 0, + level_count: 1, + base_array_layer: 0, + layer_count: 1, + }, + }; - (texture_image, texture_image_memory) - } + let mut mip_width = tex_width as i32; + let mut mip_height = tex_height as i32; - pub fn create_depth_resources( - instance: &ash::Instance, - device: &ash::Device, - physical_device: vk::PhysicalDevice, - _command_pool: vk::CommandPool, - _submit_queue: vk::Queue, - swapchain_extent: vk::Extent2D, - device_memory_properties: &vk::PhysicalDeviceMemoryProperties, - msaa_samples: vk::SampleCountFlags, - ) -> (vk::Image, vk::ImageView, vk::DeviceMemory) { - let depth_format = find_depth_format(instance, physical_device); - let (depth_image, depth_image_memory) = create_image( - device, - swapchain_extent.width, - swapchain_extent.height, - 1, - msaa_samples, - depth_format, - vk::ImageTiling::OPTIMAL, - vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT, - vk::MemoryPropertyFlags::DEVICE_LOCAL, - device_memory_properties, - ); - let depth_image_view = create_image_view( - device, - depth_image, - depth_format, - vk::ImageAspectFlags::DEPTH, - 1, - ); + for i in 1..mip_levels { + image_barrier.subresource_range.base_mip_level = i - 1; + image_barrier.old_layout = vk::ImageLayout::TRANSFER_DST_OPTIMAL; + image_barrier.new_layout = vk::ImageLayout::TRANSFER_SRC_OPTIMAL; + image_barrier.src_access_mask = vk::AccessFlags::TRANSFER_WRITE; + image_barrier.dst_access_mask = vk::AccessFlags::TRANSFER_READ; - (depth_image, depth_image_view, depth_image_memory) - } + unsafe { + device.cmd_pipeline_barrier( + command_buffer, + vk::PipelineStageFlags::TRANSFER, + vk::PipelineStageFlags::TRANSFER, + vk::DependencyFlags::empty(), + &[], + &[], + &[image_barrier.clone()], + ); + } - pub fn generate_mipmaps( - device: &ash::Device, - command_pool: vk::CommandPool, - submit_queue: vk::Queue, - image: vk::Image, - tex_width: u32, - tex_height: u32, - mip_levels: u32, - ) { - let command_buffer = begin_single_time_command(device, command_pool); - - let mut image_barrier = vk::ImageMemoryBarrier { - s_type: vk::StructureType::IMAGE_MEMORY_BARRIER, - p_next: ptr::null(), - src_access_mask: vk::AccessFlags::empty(), - dst_access_mask: vk::AccessFlags::empty(), - old_layout: vk::ImageLayout::UNDEFINED, - new_layout: vk::ImageLayout::UNDEFINED, - src_queue_family_index: vk::QUEUE_FAMILY_IGNORED, - dst_queue_family_index: vk::QUEUE_FAMILY_IGNORED, - image, - subresource_range: vk::ImageSubresourceRange { + let blits = [vk::ImageBlit { + src_subresource: vk::ImageSubresourceLayers { aspect_mask: vk::ImageAspectFlags::COLOR, - base_mip_level: 0, - level_count: 1, + mip_level: i - 1, base_array_layer: 0, layer_count: 1, }, - }; - - let mut mip_width = tex_width as i32; - let mut mip_height = tex_height as i32; - - for i in 1..mip_levels { - image_barrier.subresource_range.base_mip_level = i - 1; - image_barrier.old_layout = vk::ImageLayout::TRANSFER_DST_OPTIMAL; - image_barrier.new_layout = vk::ImageLayout::TRANSFER_SRC_OPTIMAL; - image_barrier.src_access_mask = vk::AccessFlags::TRANSFER_WRITE; - image_barrier.dst_access_mask = vk::AccessFlags::TRANSFER_READ; - - unsafe { - device.cmd_pipeline_barrier( - command_buffer, - vk::PipelineStageFlags::TRANSFER, - vk::PipelineStageFlags::TRANSFER, - vk::DependencyFlags::empty(), - &[], - &[], - &[image_barrier.clone()], - ); - } - - let blits = [vk::ImageBlit { - src_subresource: vk::ImageSubresourceLayers { - aspect_mask: vk::ImageAspectFlags::COLOR, - mip_level: i - 1, - base_array_layer: 0, - layer_count: 1, + src_offsets: [ + vk::Offset3D { x: 0, y: 0, z: 0 }, + vk::Offset3D { + x: mip_width, + y: mip_height, + z: 1, }, - src_offsets: [ - vk::Offset3D { x: 0, y: 0, z: 0 }, - vk::Offset3D { - x: mip_width, - y: mip_height, - z: 1, - }, - ], - dst_subresource: vk::ImageSubresourceLayers { - aspect_mask: vk::ImageAspectFlags::COLOR, - mip_level: i, - base_array_layer: 0, - layer_count: 1, + ], + dst_subresource: vk::ImageSubresourceLayers { + aspect_mask: vk::ImageAspectFlags::COLOR, + mip_level: i, + base_array_layer: 0, + layer_count: 1, + }, + dst_offsets: [ + vk::Offset3D { x: 0, y: 0, z: 0 }, + vk::Offset3D { + x: max(mip_width / 2, 1), + y: max(mip_height / 2, 1), + z: 1, }, - dst_offsets: [ - vk::Offset3D { x: 0, y: 0, z: 0 }, - vk::Offset3D { - x: max(mip_width / 2, 1), - y: max(mip_height / 2, 1), - z: 1, - }, - ], - }]; - - unsafe { - device.cmd_blit_image( - command_buffer, - image, - vk::ImageLayout::TRANSFER_SRC_OPTIMAL, - image, - vk::ImageLayout::TRANSFER_DST_OPTIMAL, - &blits, - vk::Filter::LINEAR, - ); - } - - image_barrier.old_layout = vk::ImageLayout::TRANSFER_SRC_OPTIMAL; - image_barrier.new_layout = vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL; - image_barrier.src_access_mask = vk::AccessFlags::TRANSFER_READ; - image_barrier.dst_access_mask = vk::AccessFlags::SHADER_READ; - - unsafe { - device.cmd_pipeline_barrier( - command_buffer, - vk::PipelineStageFlags::TRANSFER, - vk::PipelineStageFlags::FRAGMENT_SHADER, - vk::DependencyFlags::empty(), - &[], - &[], - &[image_barrier.clone()], - ); - } - - mip_width = max(mip_width / 2, 1); - mip_height = max(mip_height / 2, 1); + ], + }]; + + unsafe { + device.cmd_blit_image( + command_buffer, + image, + vk::ImageLayout::TRANSFER_SRC_OPTIMAL, + image, + vk::ImageLayout::TRANSFER_DST_OPTIMAL, + &blits, + vk::Filter::LINEAR, + ); } - image_barrier.subresource_range.base_mip_level = mip_levels - 1; - image_barrier.old_layout = vk::ImageLayout::TRANSFER_DST_OPTIMAL; + image_barrier.old_layout = vk::ImageLayout::TRANSFER_SRC_OPTIMAL; image_barrier.new_layout = vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL; - image_barrier.src_access_mask = vk::AccessFlags::TRANSFER_WRITE; + image_barrier.src_access_mask = vk::AccessFlags::TRANSFER_READ; image_barrier.dst_access_mask = vk::AccessFlags::SHADER_READ; unsafe { @@ -1004,177 +928,31 @@ pub mod v1 { ); } - end_single_time_command(device, command_pool, submit_queue, command_buffer); + mip_width = max(mip_width / 2, 1); + mip_height = max(mip_height / 2, 1); } -} - -pub mod v2 { - use ash::vk; - - use std::ptr; - - use super::*; - - pub fn create_descriptor_pool( - device: &ash::Device, - swapchain_images_size: usize, - ) -> vk::DescriptorPool { - let pool_sizes = [ - vk::DescriptorPoolSize { - // transform descriptor pool - ty: vk::DescriptorType::UNIFORM_BUFFER, - descriptor_count: swapchain_images_size as u32, - }, - vk::DescriptorPoolSize { - // sampler descriptor pool - ty: vk::DescriptorType::COMBINED_IMAGE_SAMPLER, - descriptor_count: swapchain_images_size as u32, - }, - ]; - let descriptor_pool_create_info = vk::DescriptorPoolCreateInfo { - s_type: vk::StructureType::DESCRIPTOR_POOL_CREATE_INFO, - p_next: ptr::null(), - flags: vk::DescriptorPoolCreateFlags::empty(), - max_sets: swapchain_images_size as u32, - pool_size_count: pool_sizes.len() as u32, - p_pool_sizes: pool_sizes.as_ptr(), - }; - - unsafe { - device - .create_descriptor_pool(&descriptor_pool_create_info, None) - .expect("Failed to create Descriptor Pool!") - } - } + image_barrier.subresource_range.base_mip_level = mip_levels - 1; + image_barrier.old_layout = vk::ImageLayout::TRANSFER_DST_OPTIMAL; + image_barrier.new_layout = vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL; + image_barrier.src_access_mask = vk::AccessFlags::TRANSFER_WRITE; + image_barrier.dst_access_mask = vk::AccessFlags::SHADER_READ; - pub fn create_descriptor_sets( - device: &ash::Device, - descriptor_pool: vk::DescriptorPool, - descriptor_set_layout: vk::DescriptorSetLayout, - uniforms_buffers: &Vec, - texture_image_view: vk::ImageView, - texture_sampler: vk::Sampler, - swapchain_images_size: usize, - ) -> Vec { - let mut layouts: Vec = vec![]; - for _ in 0..swapchain_images_size { - layouts.push(descriptor_set_layout); - } - - let descriptor_set_allocate_info = vk::DescriptorSetAllocateInfo { - s_type: vk::StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, - p_next: ptr::null(), - descriptor_pool, - descriptor_set_count: swapchain_images_size as u32, - p_set_layouts: layouts.as_ptr(), - }; - - let descriptor_sets = unsafe { - device - .allocate_descriptor_sets(&descriptor_set_allocate_info) - .expect("Failed to allocate descriptor sets!") - }; - - for (i, &descritptor_set) in descriptor_sets.iter().enumerate() { - let descriptor_buffer_infos = [vk::DescriptorBufferInfo { - buffer: uniforms_buffers[i], - offset: 0, - range: ::std::mem::size_of::() as u64, - }]; - - let descriptor_image_infos = [vk::DescriptorImageInfo { - sampler: texture_sampler, - image_view: texture_image_view, - image_layout: vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL, - }]; - - let descriptor_write_sets = [ - vk::WriteDescriptorSet { - // transform uniform - s_type: vk::StructureType::WRITE_DESCRIPTOR_SET, - p_next: ptr::null(), - dst_set: descritptor_set, - dst_binding: 0, - dst_array_element: 0, - descriptor_count: 1, - descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, - p_image_info: ptr::null(), - p_buffer_info: descriptor_buffer_infos.as_ptr(), - p_texel_buffer_view: ptr::null(), - }, - vk::WriteDescriptorSet { - // sampler uniform - s_type: vk::StructureType::WRITE_DESCRIPTOR_SET, - p_next: ptr::null(), - dst_set: descritptor_set, - dst_binding: 1, - dst_array_element: 0, - descriptor_count: 1, - descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER, - p_image_info: descriptor_image_infos.as_ptr(), - p_buffer_info: ptr::null(), - p_texel_buffer_view: ptr::null(), - }, - ]; - - unsafe { - device.update_descriptor_sets(&descriptor_write_sets, &[]); - } - } - - descriptor_sets + unsafe { + device.cmd_pipeline_barrier( + command_buffer, + vk::PipelineStageFlags::TRANSFER, + vk::PipelineStageFlags::FRAGMENT_SHADER, + vk::DependencyFlags::empty(), + &[], + &[], + &[image_barrier.clone()], + ); } - pub fn create_descriptor_set_layout(device: &ash::Device) -> vk::DescriptorSetLayout { - let ubo_layout_bindings = [ - vk::DescriptorSetLayoutBinding { - // transform uniform - binding: 0, - descriptor_type: vk::DescriptorType::UNIFORM_BUFFER, - descriptor_count: 1, - stage_flags: vk::ShaderStageFlags::VERTEX, - p_immutable_samplers: ptr::null(), - }, - vk::DescriptorSetLayoutBinding { - // sampler uniform - binding: 1, - descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER, - descriptor_count: 1, - stage_flags: vk::ShaderStageFlags::FRAGMENT, - p_immutable_samplers: ptr::null(), - }, - ]; - - let ubo_layout_create_info = vk::DescriptorSetLayoutCreateInfo { - s_type: vk::StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - p_next: ptr::null(), - flags: vk::DescriptorSetLayoutCreateFlags::empty(), - binding_count: ubo_layout_bindings.len() as u32, - p_bindings: ubo_layout_bindings.as_ptr(), - }; - - unsafe { - device - .create_descriptor_set_layout(&ubo_layout_create_info, None) - .expect("Failed to create Descriptor Set Layout!") - } - } + end_single_time_command(device, command_pool, submit_queue, command_buffer); } -use ash::vk; - -use std::ffi::CString; -use std::os::raw::c_char; -use std::os::raw::c_void; -use std::path::Path; -use std::ptr; - -use crate::utility::constants::*; -use crate::utility::debug; -use crate::utility::platforms; -use crate::utility::structures::*; - pub fn create_instance( entry: &ash::Entry, window_title: &str, @@ -1378,19 +1156,10 @@ pub fn create_logical_device( flags: vk::DeviceCreateFlags::empty(), queue_create_info_count: queue_create_infos.len() as u32, p_queue_create_infos: queue_create_infos.as_ptr(), - enabled_layer_count: if validation.is_enable { - enable_layer_names.len() - } else { - 0 - } as u32, - pp_enabled_layer_names: if validation.is_enable { - enable_layer_names.as_ptr() - } else { - ptr::null() - }, enabled_extension_count: enable_extension_names.len() as u32, pp_enabled_extension_names: enable_extension_names.as_ptr(), p_enabled_features: &physical_device_features, + ..Default::default() }; let device: ash::Device = unsafe { diff --git a/src/utility/structures.rs b/src/utility/structures.rs index 8dda352..898eca9 100644 --- a/src/utility/structures.rs +++ b/src/utility/structures.rs @@ -133,23 +133,3 @@ impl VertexV3 { ] } } - -pub const RECT_VERTICES_DATA: [VertexV1; 4] = [ - VertexV1 { - pos: [-0.5, -0.5], - color: [1.0, 0.0, 0.0], - }, - VertexV1 { - pos: [0.5, -0.5], - color: [0.0, 1.0, 0.0], - }, - VertexV1 { - pos: [0.5, 0.5], - color: [0.0, 0.0, 1.0], - }, - VertexV1 { - pos: [-0.5, 0.5], - color: [1.0, 1.0, 1.0], - }, -]; -pub const RECT_INDICES_DATA: [u32; 6] = [0, 1, 2, 2, 3, 0];