mirrors
/
vkd3d-proton
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

vkd3d: Rename COUNTER buffer to AUX_BUFFER. 

We will use the same pointer buffer to handle acceleration structures,
so unify this buffer under a new name. Simplifies some of the binding
code since SRV path and UAV path looks more similar now.

Only difference is that UAV path uses BDA -> uint32_t,
and SRV uses BDA -> RTAccelerationStructure.

RT requires BDA, so the fallback descriptor set (storage texel buffer) is never used for RT.

Signed-off-by: Hans-Kristian Arntzen <post@arntzen-software.no>
This commit is contained in:
Hans-Kristian Arntzen 2021-01-29 13:29:55 +01:00
parent f3becc21a4
commit fdcf583cbc
6 changed files with 68 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/vkd3d_shader.h
View File

@ -96,12 +96,12 @@ struct vkd3d_shader_descriptor_binding
enum vkd3d_shader_binding_flag
{
VKD3D_SHADER_BINDING_FLAG_BUFFER = 0x00000001,
VKD3D_SHADER_BINDING_FLAG_IMAGE = 0x00000002,
VKD3D_SHADER_BINDING_FLAG_COUNTER = 0x00000004,
VKD3D_SHADER_BINDING_FLAG_BINDLESS = 0x00000008,
VKD3D_SHADER_BINDING_FLAG_RAW_VA = 0x00000010,
VKD3D_SHADER_BINDING_FLAG_RAW_SSBO = 0x00000020,
VKD3D_SHADER_BINDING_FLAG_BUFFER = 0x00000001,
VKD3D_SHADER_BINDING_FLAG_IMAGE = 0x00000002,
VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER = 0x00000004,
VKD3D_SHADER_BINDING_FLAG_BINDLESS = 0x00000008,
VKD3D_SHADER_BINDING_FLAG_RAW_VA = 0x00000010,
VKD3D_SHADER_BINDING_FLAG_RAW_SSBO = 0x00000020,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_BINDING_FLAG),
};

8
libs/vkd3d-shader/dxil.c
View File

@ -82,7 +82,7 @@ static bool dxil_resource_is_in_range(const struct vkd3d_shader_resource_binding
static bool vkd3d_shader_binding_is_root_descriptor(const struct vkd3d_shader_resource_binding *binding)
{
const uint32_t relevant_flags = VKD3D_SHADER_BINDING_FLAG_RAW_VA |
VKD3D_SHADER_BINDING_FLAG_COUNTER;
VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER;
const uint32_t expected_flags = VKD3D_SHADER_BINDING_FLAG_RAW_VA;
return (binding->flags & relevant_flags) == expected_flags;
}
@ -324,7 +324,7 @@ static dxil_spv_bool dxil_uav_remap(void *userdata, const dxil_spv_uav_d3d_bindi
if (d3d_binding->has_counter)
{
if (!dxil_remap(remap, VKD3D_SHADER_DESCRIPTOR_TYPE_UAV, &d3d_binding->d3d_binding,
&vk_binding->counter_binding, VKD3D_SHADER_BINDING_FLAG_COUNTER))
&vk_binding->counter_binding, VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER))
{
return DXIL_SPV_FALSE;
}
@ -456,8 +456,8 @@ int vkd3d_shader_compile_dxil(const struct vkd3d_shader_code *dxbc,
/* Bindless UAV counters are implemented as physical storage buffer pointers.
* For simplicity, dxil-spirv only accepts either fully RAW VA, or all non-raw VA. */
if ((shader_interface_info->bindings[i].flags &
(VKD3D_SHADER_BINDING_FLAG_COUNTER | VKD3D_SHADER_BINDING_FLAG_BINDLESS)) ==
(VKD3D_SHADER_BINDING_FLAG_COUNTER | VKD3D_SHADER_BINDING_FLAG_BINDLESS))
(VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER | VKD3D_SHADER_BINDING_FLAG_BINDLESS)) ==
(VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER | VKD3D_SHADER_BINDING_FLAG_BINDLESS))
{
if (shader_interface_info->bindings[i].flags & VKD3D_SHADER_BINDING_FLAG_RAW_VA)
raw_va_binding_count++;

10
libs/vkd3d-shader/spirv.c
View File

@ -2558,7 +2558,7 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor
descriptor_type = vkd3d_shader_descriptor_type_from_register_type(reg->type);
assert(!is_uav_counter || descriptor_type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV);
binding_flags = is_uav_counter ? VKD3D_SHADER_BINDING_FLAG_COUNTER
binding_flags = is_uav_counter ? VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER
: vkd3d_binding_flags_from_resource_type(resource_type, raw_ssbo);
if ((resource = vkd3d_dxbc_compiler_get_resource_binding(compiler, reg, binding_flags)))
@ -5342,7 +5342,7 @@ static const struct vkd3d_shader_global_binding *vkd3d_dxbc_compiler_get_global_
}
else if (data_type == VKD3D_DATA_UAV)
{
if (binding->flags & VKD3D_SHADER_BINDING_FLAG_COUNTER)
if (binding->flags & VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER)
{
if (binding->flags & VKD3D_SHADER_BINDING_FLAG_RAW_VA)
{
@ -5733,7 +5733,7 @@ static void vkd3d_dxbc_compiler_emit_push_constant_buffers(struct vkd3d_dxbc_com
{
const struct vkd3d_shader_resource_binding *binding = &compiler->shader_interface.bindings[i];
if ((binding->flags & (VKD3D_SHADER_BINDING_FLAG_RAW_VA | VKD3D_SHADER_BINDING_FLAG_COUNTER)) == VKD3D_SHADER_BINDING_FLAG_RAW_VA)
if ((binding->flags & (VKD3D_SHADER_BINDING_FLAG_RAW_VA | VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER)) == VKD3D_SHADER_BINDING_FLAG_RAW_VA)
root_descriptor_count += 1;
}
@ -5766,7 +5766,7 @@ static void vkd3d_dxbc_compiler_emit_push_constant_buffers(struct vkd3d_dxbc_com
{
const struct vkd3d_shader_resource_binding *binding = &compiler->shader_interface.bindings[i];
if ((binding->flags & (VKD3D_SHADER_BINDING_FLAG_RAW_VA | VKD3D_SHADER_BINDING_FLAG_COUNTER)) != VKD3D_SHADER_BINDING_FLAG_RAW_VA)
if ((binding->flags & (VKD3D_SHADER_BINDING_FLAG_RAW_VA | VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER)) != VKD3D_SHADER_BINDING_FLAG_RAW_VA)
continue;
if (!uint32x2_id)
@ -6284,7 +6284,7 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp
assert(structure_stride); /* counters are valid only for structured buffers */
counter_binding = vkd3d_dxbc_compiler_get_resource_binding(compiler, reg,
VKD3D_SHADER_BINDING_FLAG_COUNTER);
VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER);
if (counter_binding && (counter_binding->flags & VKD3D_SHADER_BINDING_FLAG_BINDLESS))
{

38
libs/vkd3d/resource.c
View File

@ -3511,16 +3511,16 @@ static void d3d12_desc_copy_single(struct d3d12_desc *dst, struct d3d12_desc *sr
if (metadata.flags & VKD3D_DESCRIPTOR_FLAG_UAV_COUNTER)
{
if (dst->heap->uav_counters.host_ptr)
if (dst->heap->raw_va_aux_buffer.host_ptr)
{
const VkDeviceAddress *src_vas = src->heap->uav_counters.host_ptr;
VkDeviceAddress *dst_vas = dst->heap->uav_counters.host_ptr;
const VkDeviceAddress *src_vas = src->heap->raw_va_aux_buffer.host_ptr;
VkDeviceAddress *dst_vas = dst->heap->raw_va_aux_buffer.host_ptr;
dst_vas[dst->heap_offset] = src_vas[src->heap_offset];
}
else
{
binding = vkd3d_bindless_state_find_set(
&device->bindless_state, VKD3D_BINDLESS_SET_UAV | VKD3D_BINDLESS_SET_COUNTER);
&device->bindless_state, VKD3D_BINDLESS_SET_UAV | VKD3D_BINDLESS_SET_AUX_BUFFER);
vk_copy = &vk_copies[copy_count++];
vk_copy->sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
@ -3585,15 +3585,15 @@ void d3d12_desc_copy_range(struct d3d12_desc *dst, struct d3d12_desc *src,
if (heap_type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)
{
if (device->bindless_state.flags & VKD3D_RAW_VA_UAV_COUNTER)
if (device->bindless_state.flags & VKD3D_RAW_VA_AUX_BUFFER)
{
const VkDeviceAddress *src_vas = src->heap->uav_counters.host_ptr;
VkDeviceAddress *dst_vas = dst->heap->uav_counters.host_ptr;
const VkDeviceAddress *src_vas = src->heap->raw_va_aux_buffer.host_ptr;
VkDeviceAddress *dst_vas = dst->heap->raw_va_aux_buffer.host_ptr;
memcpy(dst_vas + dst->heap_offset, src_vas + src->heap_offset, sizeof(*dst_vas) * count);
}
else
{
binding = vkd3d_bindless_state_find_set(&device->bindless_state, VKD3D_BINDLESS_SET_UAV | VKD3D_BINDLESS_SET_COUNTER);
binding = vkd3d_bindless_state_find_set(&device->bindless_state, VKD3D_BINDLESS_SET_UAV | VKD3D_BINDLESS_SET_AUX_BUFFER);
vk_copy = &vk_copies[copy_count++];
vk_copy->sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
@ -4659,7 +4659,7 @@ static void vkd3d_create_buffer_uav(struct d3d12_desc *descriptor, struct d3d12_
assert(d3d12_resource_is_buffer(counter_resource));
assert(desc->Buffer.StructureByteStride);
if (device->bindless_state.flags & VKD3D_RAW_VA_UAV_COUNTER)
if (device->bindless_state.flags & VKD3D_RAW_VA_AUX_BUFFER)
{
VkDeviceAddress address = vkd3d_get_buffer_device_address(device, counter_resource->vk_buffer);
uav_counter_address = address + counter_resource->heap_offset + desc->Buffer.CounterOffsetInBytes;
@ -4678,16 +4678,16 @@ static void vkd3d_create_buffer_uav(struct d3d12_desc *descriptor, struct d3d12_
else if (!device->device_info.robustness2_features.nullDescriptor)
uav_counter_view = device->null_resources.vk_storage_buffer_view;
if (device->bindless_state.flags & VKD3D_RAW_VA_UAV_COUNTER)
if (device->bindless_state.flags & VKD3D_RAW_VA_AUX_BUFFER)
{
VkDeviceAddress *counter_addresses = descriptor->heap->uav_counters.host_ptr;
VkDeviceAddress *counter_addresses = descriptor->heap->raw_va_aux_buffer.host_ptr;
uint32_t descriptor_index = d3d12_desc_heap_offset(descriptor);
counter_addresses[descriptor_index] = uav_counter_address;
}
else
{
struct vkd3d_descriptor_binding binding = vkd3d_bindless_state_find_set(
&device->bindless_state, VKD3D_BINDLESS_SET_UAV | VKD3D_BINDLESS_SET_COUNTER);
&device->bindless_state, VKD3D_BINDLESS_SET_UAV | VKD3D_BINDLESS_SET_AUX_BUFFER);
descriptor_info[vk_write_count].buffer_view = uav_counter_view;
vkd3d_init_write_descriptor_set(&vk_write[vk_write_count], descriptor,
@ -5729,7 +5729,7 @@ static HRESULT d3d12_descriptor_heap_init_data_buffer(struct d3d12_descriptor_he
const struct vkd3d_vk_device_procs *vk_procs = &descriptor_heap->device->vk_procs;
VkDeviceSize alignment = max(device->device_info.properties2.properties.limits.minStorageBufferOffsetAlignment,
device->device_info.properties2.properties.limits.nonCoherentAtomSize);
VkDeviceSize uav_counter_size = 0, offset_buffer_size = 0;
VkDeviceSize raw_va_buffer_size = 0, offset_buffer_size = 0;
VkDeviceSize buffer_size, offset;
D3D12_HEAP_PROPERTIES heap_info;
D3D12_RESOURCE_DESC buffer_desc;
@ -5739,14 +5739,14 @@ static HRESULT d3d12_descriptor_heap_init_data_buffer(struct d3d12_descriptor_he
if (desc->Type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)
{
if (device->bindless_state.flags & VKD3D_RAW_VA_UAV_COUNTER)
uav_counter_size = align(desc->NumDescriptors * sizeof(VkDeviceAddress), alignment);
if (device->bindless_state.flags & VKD3D_RAW_VA_AUX_BUFFER)
raw_va_buffer_size = align(desc->NumDescriptors * sizeof(VkDeviceAddress), alignment);
if (device->bindless_state.flags & (VKD3D_SSBO_OFFSET_BUFFER | VKD3D_TYPED_OFFSET_BUFFER))
offset_buffer_size = align(desc->NumDescriptors * sizeof(struct vkd3d_bound_buffer_range), alignment);
}
buffer_size = uav_counter_size + offset_buffer_size;
buffer_size = raw_va_buffer_size + offset_buffer_size;
if (!buffer_size)
return S_OK;
@ -5792,7 +5792,7 @@ static HRESULT d3d12_descriptor_heap_init_data_buffer(struct d3d12_descriptor_he
offset = 0;
d3d12_descriptor_heap_get_buffer_range(descriptor_heap, &offset, uav_counter_size, &descriptor_heap->uav_counters);
d3d12_descriptor_heap_get_buffer_range(descriptor_heap, &offset, raw_va_buffer_size, &descriptor_heap->raw_va_aux_buffer);
d3d12_descriptor_heap_get_buffer_range(descriptor_heap, &offset, offset_buffer_size, &descriptor_heap->buffer_ranges);
return S_OK;
}
@ -5835,8 +5835,8 @@ static void d3d12_descriptor_heap_update_extra_bindings(struct d3d12_descriptor_
switch (flag)
{
case VKD3D_BINDLESS_SET_EXTRA_UAV_COUNTER_BUFFER:
*vk_buffer = descriptor_heap->uav_counters.descriptor;
case VKD3D_BINDLESS_SET_EXTRA_RAW_VA_AUX_BUFFER:
*vk_buffer = descriptor_heap->raw_va_aux_buffer.descriptor;
break;
case VKD3D_BINDLESS_SET_EXTRA_OFFSET_BUFFER:

53
libs/vkd3d/state.c
View File

@ -329,7 +329,7 @@ struct d3d12_root_signature_info
uint32_t push_descriptor_count;
uint32_t root_constant_count;
bool has_raw_va_uav_counters;
bool has_raw_va_aux_buffer;
bool has_ssbo_offset_buffer;
bool has_typed_offset_buffer;
@ -342,27 +342,15 @@ static HRESULT d3d12_root_signature_info_count_descriptors(struct d3d12_root_sig
switch (range->RangeType)
{
case D3D12_DESCRIPTOR_RANGE_TYPE_SRV:
/* separate image + buffer descriptors */
info->binding_count += 2;
if (device->bindless_state.flags & VKD3D_BINDLESS_RAW_SSBO)
info->binding_count += 1;
if (device->bindless_state.flags & VKD3D_SSBO_OFFSET_BUFFER)
info->has_ssbo_offset_buffer = true;
if (device->bindless_state.flags & VKD3D_TYPED_OFFSET_BUFFER)
info->has_typed_offset_buffer = true;
break;
case D3D12_DESCRIPTOR_RANGE_TYPE_UAV:
/* separate image + buffer descriptors */
/* separate image + buffer descriptors + aux buffer descriptor. */
info->binding_count += 3;
if (device->bindless_state.flags & VKD3D_BINDLESS_RAW_SSBO)
info->binding_count += 1;
if (device->bindless_state.flags & VKD3D_RAW_VA_UAV_COUNTER)
info->has_raw_va_uav_counters = true;
if (device->bindless_state.flags & VKD3D_RAW_VA_AUX_BUFFER)
info->has_raw_va_aux_buffer = true;
if (device->bindless_state.flags & VKD3D_SSBO_OFFSET_BUFFER)
info->has_ssbo_offset_buffer = true;
if (device->bindless_state.flags & VKD3D_TYPED_OFFSET_BUFFER)
@ -646,20 +634,19 @@ static HRESULT d3d12_root_signature_init_root_descriptor_tables(struct d3d12_roo
}
break;
case D3D12_DESCRIPTOR_RANGE_TYPE_UAV:
binding.flags = VKD3D_SHADER_BINDING_FLAG_BINDLESS |
VKD3D_SHADER_BINDING_FLAG_COUNTER;
case D3D12_DESCRIPTOR_RANGE_TYPE_SRV:
binding.flags = VKD3D_SHADER_BINDING_FLAG_BINDLESS | VKD3D_SHADER_BINDING_FLAG_AUX_BUFFER;
if (root_signature->flags & VKD3D_ROOT_SIGNATURE_USE_RAW_VA_UAV_COUNTERS)
if (root_signature->flags & VKD3D_ROOT_SIGNATURE_USE_RAW_VA_AUX_BUFFER)
{
binding.flags |= VKD3D_SHADER_BINDING_FLAG_RAW_VA;
binding.binding = root_signature->uav_counter_binding;
binding.binding = root_signature->raw_va_aux_buffer_binding;
}
else if (!vkd3d_bindless_state_find_binding(bindless_state, range_flag | VKD3D_BINDLESS_SET_COUNTER, &binding.binding))
ERR("Failed to find UAV counter binding.\n");
else if (!vkd3d_bindless_state_find_binding(bindless_state, range_flag | VKD3D_BINDLESS_SET_AUX_BUFFER, &binding.binding))
ERR("Failed to find aux buffer binding.\n");
table->first_binding[table->binding_count++] = binding;
/* fall through */
case D3D12_DESCRIPTOR_RANGE_TYPE_SRV:
if (vkd3d_bindless_state_find_binding(bindless_state, range_flag | VKD3D_BINDLESS_SET_BUFFER, &binding.binding))
{
binding.flags = VKD3D_SHADER_BINDING_FLAG_BINDLESS | VKD3D_SHADER_BINDING_FLAG_BUFFER;
@ -694,13 +681,13 @@ static HRESULT d3d12_root_signature_init_root_descriptor_tables(struct d3d12_roo
static void d3d12_root_signature_init_extra_bindings(struct d3d12_root_signature *root_signature,
const struct d3d12_root_signature_info *info)
{
if (info->has_raw_va_uav_counters)
if (info->has_raw_va_aux_buffer)
{
root_signature->flags |= VKD3D_ROOT_SIGNATURE_USE_RAW_VA_UAV_COUNTERS;
root_signature->flags |= VKD3D_ROOT_SIGNATURE_USE_RAW_VA_AUX_BUFFER;
vkd3d_bindless_state_find_binding(&root_signature->device->bindless_state,
VKD3D_BINDLESS_SET_EXTRA_UAV_COUNTER_BUFFER,
&root_signature->uav_counter_binding);
VKD3D_BINDLESS_SET_EXTRA_RAW_VA_AUX_BUFFER,
&root_signature->raw_va_aux_buffer_binding);
}
if (info->has_ssbo_offset_buffer || info->has_typed_offset_buffer)
@ -3895,7 +3882,7 @@ static uint32_t vkd3d_bindless_state_get_bindless_flags(struct d3d12_device *dev
flags |= VKD3D_TYPED_OFFSET_BUFFER;
if (device_info->buffer_device_address_features.bufferDeviceAddress && (flags & VKD3D_BINDLESS_UAV))
flags |= VKD3D_RAW_VA_UAV_COUNTER;
flags |= VKD3D_RAW_VA_AUX_BUFFER;
/* We must use root SRV and UAV due to alignment requirements for 16-bit storage,
* but root CBV is more lax. */
@ -3938,8 +3925,8 @@ HRESULT vkd3d_bindless_state_init(struct vkd3d_bindless_state *bindless_state,
goto fail;
}
if (bindless_state->flags & VKD3D_RAW_VA_UAV_COUNTER)
extra_bindings |= VKD3D_BINDLESS_SET_EXTRA_UAV_COUNTER_BUFFER;
if (bindless_state->flags & VKD3D_RAW_VA_AUX_BUFFER)
extra_bindings |= VKD3D_BINDLESS_SET_EXTRA_RAW_VA_AUX_BUFFER;
if (bindless_state->flags & (VKD3D_SSBO_OFFSET_BUFFER | VKD3D_TYPED_OFFSET_BUFFER))
extra_bindings |= VKD3D_BINDLESS_SET_EXTRA_OFFSET_BUFFER;
@ -3993,10 +3980,10 @@ HRESULT vkd3d_bindless_state_init(struct vkd3d_bindless_state *bindless_state,
goto fail;
}
if (!(bindless_state->flags & VKD3D_RAW_VA_UAV_COUNTER))
if (!(bindless_state->flags & VKD3D_RAW_VA_AUX_BUFFER))
{
if (FAILED(hr = vkd3d_bindless_state_add_binding(bindless_state, device,
VKD3D_BINDLESS_SET_UAV | VKD3D_BINDLESS_SET_COUNTER,
VKD3D_BINDLESS_SET_UAV | VKD3D_BINDLESS_SET_AUX_BUFFER,
VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)))
goto fail;
}

28
libs/vkd3d/vkd3d_private.h
View File

@ -749,7 +749,7 @@ struct d3d12_descriptor_heap
VkBuffer vk_buffer;
void *host_memory;
struct vkd3d_host_visible_buffer_range uav_counters;
struct vkd3d_host_visible_buffer_range raw_va_aux_buffer;
struct vkd3d_host_visible_buffer_range buffer_ranges;
struct d3d12_device *device;
@ -801,7 +801,7 @@ enum vkd3d_root_signature_flag
{
VKD3D_ROOT_SIGNATURE_USE_ROOT_DESCRIPTOR_SET = 0x00000001u,
VKD3D_ROOT_SIGNATURE_USE_INLINE_UNIFORM_BLOCK = 0x00000002u,
VKD3D_ROOT_SIGNATURE_USE_RAW_VA_UAV_COUNTERS = 0x00000004u,
VKD3D_ROOT_SIGNATURE_USE_RAW_VA_AUX_BUFFER = 0x00000004u,
VKD3D_ROOT_SIGNATURE_USE_SSBO_OFFSET_BUFFER = 0x00000008u,
VKD3D_ROOT_SIGNATURE_USE_TYPED_OFFSET_BUFFER = 0x00000010u,
};
@ -871,7 +871,7 @@ struct d3d12_root_signature
/* Use one global push constant range */
VkPushConstantRange push_constant_range;
struct vkd3d_shader_descriptor_binding push_constant_ubo_binding;
struct vkd3d_shader_descriptor_binding uav_counter_binding;
struct vkd3d_shader_descriptor_binding raw_va_aux_buffer_binding;
struct vkd3d_shader_descriptor_binding offset_buffer_binding;
uint32_t descriptor_table_offset;
@ -1671,7 +1671,7 @@ enum vkd3d_bindless_flags
VKD3D_BINDLESS_CBV = (1u << 1),
VKD3D_BINDLESS_SRV = (1u << 2),
VKD3D_BINDLESS_UAV = (1u << 3),
VKD3D_RAW_VA_UAV_COUNTER = (1u << 4),
VKD3D_RAW_VA_AUX_BUFFER = (1u << 4),
VKD3D_BINDLESS_CBV_AS_SSBO = (1u << 5),
VKD3D_BINDLESS_RAW_SSBO = (1u << 6),
VKD3D_SSBO_OFFSET_BUFFER = (1u << 7),
@ -1685,17 +1685,17 @@ enum vkd3d_bindless_flags
enum vkd3d_bindless_set_flag
{
VKD3D_BINDLESS_SET_SAMPLER = (1u << 0),
VKD3D_BINDLESS_SET_CBV = (1u << 1),
VKD3D_BINDLESS_SET_SRV = (1u << 2),
VKD3D_BINDLESS_SET_UAV = (1u << 3),
VKD3D_BINDLESS_SET_IMAGE = (1u << 4),
VKD3D_BINDLESS_SET_BUFFER = (1u << 5),
VKD3D_BINDLESS_SET_COUNTER = (1u << 6),
VKD3D_BINDLESS_SET_RAW_SSBO = (1u << 7),
VKD3D_BINDLESS_SET_MUTABLE = (1u << 8),
VKD3D_BINDLESS_SET_SAMPLER = (1u << 0),
VKD3D_BINDLESS_SET_CBV = (1u << 1),
VKD3D_BINDLESS_SET_SRV = (1u << 2),
VKD3D_BINDLESS_SET_UAV = (1u << 3),
VKD3D_BINDLESS_SET_IMAGE = (1u << 4),
VKD3D_BINDLESS_SET_BUFFER = (1u << 5),
VKD3D_BINDLESS_SET_AUX_BUFFER = (1u << 6),
VKD3D_BINDLESS_SET_RAW_SSBO = (1u << 7),
VKD3D_BINDLESS_SET_MUTABLE = (1u << 8),
VKD3D_BINDLESS_SET_EXTRA_UAV_COUNTER_BUFFER = (1u << 24),
VKD3D_BINDLESS_SET_EXTRA_RAW_VA_AUX_BUFFER = (1u << 24),
VKD3D_BINDLESS_SET_EXTRA_OFFSET_BUFFER = (1u << 25),
VKD3D_BINDLESS_SET_EXTRA_MASK = 0xff000000u
};