A very lightweight wrapper around Vulkan
No.
Functions return a type VkResult<T> = Result<T, vk::Result> instead of an error code. No mutable references for the output are required.
Rust
pub fn create_swapchain_khr(&self,
create_info: &vk::SwapchainCreateInfoKHR)
-> VkResult<vk::SwapchainKHR>;
let swapchain = device.create_swapchain_khr(&swapchain_create_info).unwrap();
Always returns a Vec<T> for functions that output multiple values.
Rust
pub fn get_swapchain_images_khr(&self,
swapchain: vk::SwapchainKHR)
-> VkResult<Vec<vk::Image>>;
let present_images = device.get_swapchain_images_khr(swapchain).unwrap();
Ash always uses slices in functions.
```Rust
// C
void vkCmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers);
// Rust pub fn cmdpipelinebarrier(&self, commandbuffer: vk::CommandBuffer, srcstagemask: vk::PipelineStageFlags, dststagemask: vk::PipelineStageFlags, dependencyflags: vk::DependencyFlags, memorybarriers: &[vk::MemoryBarrier], buffermemorybarriers: &[vk::BufferMemoryBarrier], imagememory_barriers: &[vk::ImageMemoryBarrier]);
device.cmdpipelinebarrier(setupcommandbuffer, vk::PIPELINESTAGETOPOFPIPEBIT, vk::PIPELINESTAGETOPOFPIPEBIT, vk::DependencyFlags::empty(), &[], &[], &[layouttransitionbarrier]);
// or
let slice = device.mapmemory::
Ash still uses raw Vulkan structs. The only difference is type safety. Everything that can be an enum is an enum like `vk::StructureType`, flags are implemented similar to the `Bitflags` crate. Ash also follows the Rust style guide. The reason that Ash uses raw Vulkan structs is to be extensible, just like the Vulkan spec.
Rust
let poolcreateinfo = vk::CommandPoolCreateInfo {
stype: vk::StructureType::CommandPoolCreateInfo,
pnext: ptr::null(),
flags: vk::COMMANDPOOLCREATERESETCOMMANDBUFFERBIT,
queuefamilyindex: queuefamilyindex,
};
let pool = device.createcommandpool(&poolcreateinfo).unwrap();
Ash also takes care of loading the function pointers. Function pointers are split into 3 categories. Entry, Instance and Device. The reason for not loading it into a global is that in Vulkan you can have multiple devices and each device must load its own function pointers.
Rust
// Looks for the vulkan lib in your path, alternatively you can supply the path explicitly.
let entry = Entry::loadvulkan().unwrap();
let instance: Instance = entry.createinstance(&createinfo).expect("Instance creation error");
let device: Device = instance.createdevice(pdevice, &devicecreateinfo)
.unwrap();
Additionally, every Vulkan extension has to be loaded explicity. You can find all extensions under [ash::extensions](https://github.com/MaikKlein/ash/tree/master/src/extensions). You still have to tell Vulkan which instance or device extensions you want to load.
Rust
use ash::extensions::Swapchain;
let swapchainloader = Swapchain::new(&instance, &device).expect("Unable to load swapchain");
let swapchain = swapchainloader.createswapchainkhr(&swapchaincreate_info).unwrap();
You don't have to pass an Instance or Device handle anymore, this is done implicitly for you.
Rust
// C
VkResult vkCreateCommandPool(
VkDevice device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool);
// Rust
pub fn createcommandpool(&self,
create_info: &vk::CommandPoolCreateInfo)
-> VkResult
let pool = device.createcommandpool(&poolcreateinfo).unwrap(); ```
You can find the examples here.
Currently only runs under Linux (x11) and requires GLFW, the LunarG Validation layers, a Vulkan library. Ports for other operating systems are in progress. (Currently the GLFW wrapper only wraps the low level x11 bindings)
The triangle example is written from top to bottom without many helper functions or external dependencies. It renders a colored triangle. The shaders a written in GLSL and compiled into SPIR-V with glslang
cd examples/triangle
cargo run
Displays a texture on a quad. Needs a cleanup.
cd examples/texture
cargo run
