Struct vma::AllocationCreateFlags
source · pub struct AllocationCreateFlags { /* private fields */ }
Expand description
Flags for configuring Allocation
construction.
Implementations§
source§impl AllocationCreateFlags
impl AllocationCreateFlags
sourcepub const DEDICATED_MEMORY: Self = _
pub const DEDICATED_MEMORY: Self = _
Set this flag if the allocation should have its own memory block.
Use it for special, big resources, like fullscreen images used as attachments.
sourcepub const NEVER_ALLOCATE: Self = _
pub const NEVER_ALLOCATE: Self = _
Set this flag to only try to allocate from existing ash::vk::DeviceMemory
blocks and never create new such block.
If new allocation cannot be placed in any of the existing blocks, allocation
fails with ash::vk::Result::ERROR_OUT_OF_DEVICE_MEMORY
error.
You should not use AllocationCreateFlags::DEDICATED_MEMORY
and AllocationCreateFlags::NEVER_ALLOCATE
at the same time. It makes no sense.
sourcepub const MAPPED: Self = _
pub const MAPPED: Self = _
Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
Pointer to mapped memory will be returned through Allocation::get_mapped_data()
.
Is it valid to use this flag for allocation made from memory type that is not
ash::vk::MemoryPropertyFlags::HOST_VISIBLE
. This flag is then ignored and memory is not mapped. This is
useful if you need an allocation that is efficient to use on GPU
(ash::vk::MemoryPropertyFlags::DEVICE_LOCAL
) and still want to map it directly if possible on platforms that
support it (e.g. Intel GPU).
You should not use this flag together with AllocationCreateFlags::CAN_BECOME_LOST
.
sourcepub const USER_DATA_COPY_STRING: Self = _
👎Deprecated since 0.3: Consider using vmaSetAllocationName() instead.
pub const USER_DATA_COPY_STRING: Self = _
Set this flag to treat AllocationCreateInfo::user_data
as pointer to a
null-terminated string. Instead of copying pointer value, a local copy of the
string is made and stored in allocation’s user data. The string is automatically
freed together with the allocation. It is also used in Allocator::build_stats_string
.
sourcepub const UPPER_ADDRESS: Self = _
pub const UPPER_ADDRESS: Self = _
Allocation will be created from upper stack in a double stack pool.
This flag is only allowed for custom pools created with AllocatorPoolCreateFlags::LINEAR_ALGORITHM
flag.
sourcepub const DONT_BIND: Self = _
pub const DONT_BIND: Self = _
Create both buffer/image and allocation, but don’t bind them together.
It is useful when you want to bind yourself to do some more advanced binding, e.g. using some extensions.
The flag is meaningful only with functions that bind by default, such as Allocator::create_buffer
or Allocator::create_image
. Otherwise it is ignored.
If you want to make sure the new buffer/image is not tied to the new memory allocation
through VkMemoryDedicatedAllocateInfoKHR
structure in case the allocation ends up in its own memory block,
use also flag #VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT.
sourcepub const WITHIN_BUDGET: Self = _
pub const WITHIN_BUDGET: Self = _
Create allocation only if additional device memory required for it, if any, won’t exceed
memory budget. Otherwise return VK_ERROR_OUT_OF_DEVICE_MEMORY
.
sourcepub const CAN_ALIAS: Self = _
pub const CAN_ALIAS: Self = _
Set this flag if the allocated memory will have aliasing resources.
Usage of this flag prevents supplying VkMemoryDedicatedAllocateInfoKHR
when #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT is specified.
Otherwise created dedicated memory will not be suitable for aliasing resources, resulting in Vulkan Validation Layer errors.
sourcepub const HOST_ACCESS_SEQUENTIAL_WRITE: Self = _
pub const HOST_ACCESS_SEQUENTIAL_WRITE: Self = _
Requests possibility to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT).
- If you use #VMA_MEMORY_USAGE_AUTO or other
VMA_MEMORY_USAGE_AUTO*
value, you must use this flag to be able to map the allocation. Otherwise, mapping is incorrect. - If you use other value of #VmaMemoryUsage, this flag is ignored and mapping is always possible in memory types that are
HOST_VISIBLE
. This includes allocations created in custom_memory_pools.
Declares that mapped memory will only be written sequentially, e.g. using memcpy()
or a loop writing number-by-number,
never read or accessed randomly, so a memory type can be selected that is uncached and write-combined.
Violating this declaration may work correctly, but will likely be very slow.
Watch out for implicit reads introduced by doing e.g. pMappedData[i] += x;
Better prepare your data in a local variable and memcpy()
it to the mapped pointer all at once.
sourcepub const HOST_ACCESS_RANDOM: Self = _
pub const HOST_ACCESS_RANDOM: Self = _
Requests possibility to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT).
- If you use #VMA_MEMORY_USAGE_AUTO or other
VMA_MEMORY_USAGE_AUTO*
value, you must use this flag to be able to map the allocation. Otherwise, mapping is incorrect. - If you use other value of #VmaMemoryUsage, this flag is ignored and mapping is always possible in memory types that are
HOST_VISIBLE
. This includes allocations created in custom_memory_pools.
Declares that mapped memory can be read, written, and accessed in random order,
so a HOST_CACHED
memory type is required.
sourcepub const HOST_ACCESS_ALLOW_TRANSFER_INSTEAD: Self = _
pub const HOST_ACCESS_ALLOW_TRANSFER_INSTEAD: Self = _
Together with #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT,
it says that despite request for host access, a not-HOST_VISIBLE
memory type can be selected
if it may improve performance.
By using this flag, you declare that you will check if the allocation ended up in a HOST_VISIBLE
memory type
(e.g. using vmaGetAllocationMemoryProperties()) and if not, you will create some “staging” buffer and
issue an explicit transfer to write/read your data.
To prepare for this possibility, don’t forget to add appropriate flags like
VK_BUFFER_USAGE_TRANSFER_DST_BIT
, VK_BUFFER_USAGE_TRANSFER_SRC_BIT
to the parameters of created buffer or image.
sourcepub const STRATEGY_MIN_MEMORY: Self = _
pub const STRATEGY_MIN_MEMORY: Self = _
Allocation strategy that chooses smallest possible free range for the allocation to minimize memory usage and fragmentation, possibly at the expense of allocation time.
sourcepub const STRATEGY_BEST_FIT: Self = _
pub const STRATEGY_BEST_FIT: Self = _
Alias to STRATEGY_MIN_MEMORY
.
sourcepub const STRATEGY_MIN_TIME: Self = _
pub const STRATEGY_MIN_TIME: Self = _
Allocation strategy that chooses first suitable free range for the allocation - not necessarily in terms of the smallest offset but the one that is easiest and fastest to find to minimize allocation time, possibly at the expense of allocation quality.
sourcepub const STRATEGY_FIRST_FIT: Self = _
pub const STRATEGY_FIRST_FIT: Self = _
Alias to STRATEGY_MIN_TIME
.
sourcepub const STRATEGY_MIN_OFFSET: Self = _
pub const STRATEGY_MIN_OFFSET: Self = _
Allocation strategy that chooses always the lowest offset in available space. This is not the most efficient strategy but achieves highly packed data. Used internally by defragmentation, not recomended in typical usage.
sourcepub const fn from_bits(bits: u32) -> Option<Self>
pub const fn from_bits(bits: u32) -> Option<Self>
Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.
sourcepub const fn from_bits_truncate(bits: u32) -> Self
pub const fn from_bits_truncate(bits: u32) -> Self
Convert from underlying bit representation, dropping any bits that do not correspond to flags.
sourcepub const unsafe fn from_bits_unchecked(bits: u32) -> Self
pub const unsafe fn from_bits_unchecked(bits: u32) -> Self
Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).
Safety
The caller of the bitflags!
macro can chose to allow or
disallow extra bits for their bitflags type.
The caller of from_bits_unchecked()
has to ensure that
all bits correspond to a defined flag or that extra bits
are valid for this bitflags type.
sourcepub const fn intersects(&self, other: Self) -> bool
pub const fn intersects(&self, other: Self) -> bool
Returns true
if there are flags common to both self
and other
.
sourcepub const fn contains(&self, other: Self) -> bool
pub const fn contains(&self, other: Self) -> bool
Returns true
if all of the flags in other
are contained within self
.
sourcepub fn set(&mut self, other: Self, value: bool)
pub fn set(&mut self, other: Self, value: bool)
Inserts or removes the specified flags depending on the passed value.
sourcepub const fn intersection(self, other: Self) -> Self
pub const fn intersection(self, other: Self) -> Self
Returns the intersection between the flags in self
and
other
.
Specifically, the returned set contains only the flags which are
present in both self
and other
.
This is equivalent to using the &
operator (e.g.
ops::BitAnd
), as in flags & other
.
sourcepub const fn union(self, other: Self) -> Self
pub const fn union(self, other: Self) -> Self
Returns the union of between the flags in self
and other
.
Specifically, the returned set contains all flags which are
present in either self
or other
, including any which are
present in both (see Self::symmetric_difference
if that
is undesirable).
This is equivalent to using the |
operator (e.g.
ops::BitOr
), as in flags | other
.
sourcepub const fn difference(self, other: Self) -> Self
pub const fn difference(self, other: Self) -> Self
Returns the difference between the flags in self
and other
.
Specifically, the returned set contains all flags present in
self
, except for the ones present in other
.
It is also conceptually equivalent to the “bit-clear” operation:
flags & !other
(and this syntax is also supported).
This is equivalent to using the -
operator (e.g.
ops::Sub
), as in flags - other
.
sourcepub const fn symmetric_difference(self, other: Self) -> Self
pub const fn symmetric_difference(self, other: Self) -> Self
Returns the symmetric difference between the flags
in self
and other
.
Specifically, the returned set contains the flags present which
are present in self
or other
, but that are not present in
both. Equivalently, it contains the flags present in exactly
one of the sets self
and other
.
This is equivalent to using the ^
operator (e.g.
ops::BitXor
), as in flags ^ other
.
sourcepub const fn complement(self) -> Self
pub const fn complement(self) -> Self
Returns the complement of this set of flags.
Specifically, the returned set contains all the flags which are
not set in self
, but which are allowed for this type.
Alternatively, it can be thought of as the set difference
between Self::all()
and self
(e.g. Self::all() - self
)
This is equivalent to using the !
operator (e.g.
ops::Not
), as in !flags
.
Trait Implementations§
source§impl Binary for AllocationCreateFlags
impl Binary for AllocationCreateFlags
source§impl BitAndAssign<AllocationCreateFlags> for AllocationCreateFlags
impl BitAndAssign<AllocationCreateFlags> for AllocationCreateFlags
source§fn bitand_assign(&mut self, other: Self)
fn bitand_assign(&mut self, other: Self)
Disables all flags disabled in the set.
source§impl BitOr<AllocationCreateFlags> for AllocationCreateFlags
impl BitOr<AllocationCreateFlags> for AllocationCreateFlags
source§fn bitor(self, other: AllocationCreateFlags) -> Self
fn bitor(self, other: AllocationCreateFlags) -> Self
Returns the union of the two sets of flags.
§type Output = AllocationCreateFlags
type Output = AllocationCreateFlags
|
operator.source§impl BitOrAssign<AllocationCreateFlags> for AllocationCreateFlags
impl BitOrAssign<AllocationCreateFlags> for AllocationCreateFlags
source§fn bitor_assign(&mut self, other: Self)
fn bitor_assign(&mut self, other: Self)
Adds the set of flags.
source§impl BitXorAssign<AllocationCreateFlags> for AllocationCreateFlags
impl BitXorAssign<AllocationCreateFlags> for AllocationCreateFlags
source§fn bitxor_assign(&mut self, other: Self)
fn bitxor_assign(&mut self, other: Self)
Toggles the set of flags.
source§impl Clone for AllocationCreateFlags
impl Clone for AllocationCreateFlags
source§fn clone(&self) -> AllocationCreateFlags
fn clone(&self) -> AllocationCreateFlags
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Debug for AllocationCreateFlags
impl Debug for AllocationCreateFlags
source§impl Extend<AllocationCreateFlags> for AllocationCreateFlags
impl Extend<AllocationCreateFlags> for AllocationCreateFlags
source§fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)
fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl FromIterator<AllocationCreateFlags> for AllocationCreateFlags
impl FromIterator<AllocationCreateFlags> for AllocationCreateFlags
source§fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self
fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self
source§impl Hash for AllocationCreateFlags
impl Hash for AllocationCreateFlags
source§impl LowerHex for AllocationCreateFlags
impl LowerHex for AllocationCreateFlags
source§impl Not for AllocationCreateFlags
impl Not for AllocationCreateFlags
source§impl Octal for AllocationCreateFlags
impl Octal for AllocationCreateFlags
source§impl Ord for AllocationCreateFlags
impl Ord for AllocationCreateFlags
source§fn cmp(&self, other: &AllocationCreateFlags) -> Ordering
fn cmp(&self, other: &AllocationCreateFlags) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere Self: Sized,
source§impl PartialEq<AllocationCreateFlags> for AllocationCreateFlags
impl PartialEq<AllocationCreateFlags> for AllocationCreateFlags
source§fn eq(&self, other: &AllocationCreateFlags) -> bool
fn eq(&self, other: &AllocationCreateFlags) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl PartialOrd<AllocationCreateFlags> for AllocationCreateFlags
impl PartialOrd<AllocationCreateFlags> for AllocationCreateFlags
source§fn partial_cmp(&self, other: &AllocationCreateFlags) -> Option<Ordering>
fn partial_cmp(&self, other: &AllocationCreateFlags) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl SubAssign<AllocationCreateFlags> for AllocationCreateFlags
impl SubAssign<AllocationCreateFlags> for AllocationCreateFlags
source§fn sub_assign(&mut self, other: Self)
fn sub_assign(&mut self, other: Self)
Disables all flags enabled in the set.