Magnum::Vk::Fence class new in Git master

Fence.

Wraps a VkFence.

Fence creation

A fence doesn't need any extra parameters for construction and can be constructed directly using Fence(Device&, const FenceCreateInfo&), leaving the info parameter at its default. If you want to pass additional parameters to it, include the FenceCreateInfo class as usual:

#include <Magnum/Vk/FenceCreateInfo.h>



Vk::Fence fence{device, Vk::FenceCreateInfo{Vk::FenceCreateInfo::Flag::Signaled}};

Basic usage

By default a fence is created unsignaled. It can be created in a signaled state using FenceCreateInfo::Flag::Signaled and its signaled state reset back via reset(). Fence status can be queried immediately via status() and waited on using wait().

See Command buffer recording and submit for an example usage in command buffer submission.

Public static functions

static auto wrap(Device& device, VkFence handle, HandleFlags flags = {}) -> Fence
Wrap existing Vulkan handle.

Constructors, destructors, conversion operators

Fence(Device& device, const FenceCreateInfo& info = FenceCreateInfo{}) explicit
Constructor.
Fence(NoCreateT) explicit
Construct without creating the fence.
Fence(const Fence&) deleted
Copying is not allowed.
Fence(Fence&& other) noexcept
Move constructor.
~Fence()
Destructor.
operator VkFence()

Public functions

auto operator=(const Fence&) -> Fence& deleted
Copying is not allowed.
auto operator=(Fence&& other) -> Fence& noexcept
Move assignment.
auto handle() -> VkFence
Underlying VkFence handle.
auto handleFlags() const -> HandleFlags
Handle flags.
void reset()
Reset the fence.
auto status() -> bool
Fence status.
auto wait(std::chrono::nanoseconds timeout) -> bool
Wait for the fence to become signaled.
void wait()
Wait indefinitely for the fence to become signaled.
auto release() -> VkFence
Release the underlying Vulkan fence.

Function documentation

static Fence Magnum::Vk::Fence::wrap(Device& device, VkFence handle, HandleFlags flags = {})

Wrap existing Vulkan handle.

Parameters
device Vulkan device the fence is created on
handle The VkFence handle
flags Handle flags

The handle is expected to be originating from device. Unlike a fence created using a constructor, the Vulkan fence is by default not deleted on destruction, use flags for different behavior.

Magnum::Vk::Fence::Fence(Device& device, const FenceCreateInfo& info = FenceCreateInfo{}) explicit

Constructor.

Parameters
device Vulkan device to create the fence on
info Fence creation info

Magnum::Vk::Fence::Fence(NoCreateT) explicit

Construct without creating the fence.

The constructed instance is equivalent to moved-from state. Useful in cases where you will overwrite the instance later anyway. Move another object over it to make it useful.

Magnum::Vk::Fence::~Fence()

Destructor.

Destroys associated VkFence handle, unless the instance was created using wrap() without HandleFlag::DestroyOnDestruction specified.

Magnum::Vk::Fence::operator VkFence()

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Vk::Fence::reset()

Reset the fence.

Sets the state of a fence to unsignaled from the host.

bool Magnum::Vk::Fence::status()

Fence status.

Returns true if the fence is signaled and false if unsignaled.

bool Magnum::Vk::Fence::wait(std::chrono::nanoseconds timeout)

Wait for the fence to become signaled.

Blocks until the fence becomes signaled or timeout is elapsed, whichever happens sooner, returning true is the fence became signaled. If the fence is already signaled, the function returns immediately, if the timeout happens before the fence becomes signaled, false is returned.

Calling this function with zero timeout is equivalent to calling status().

void Magnum::Vk::Fence::wait()

Wait indefinitely for the fence to become signaled.

Equivalent to calling wait(std::chrono::nanoseconds) with the largest representable 64-bit value.

VkFence Magnum::Vk::Fence::release()

Release the underlying Vulkan fence.

Releases ownership of the Vulkan fence and returns its handle so vkDestroyFence() is not called on destruction. The internal state is then equivalent to moved-from state.