mirror of
https://github.com/Rosalie241/RMG.git
synced 2026-11-16 10:53:16 +01:00
Revert "3rdParty: update mupen64plus-video-parallel"
This commit is contained in:
1 parent
487c84c085
commit
e76fcd3bd3
86 files changed
+51102
-60057
No files matched your search
+2
-2
@@ -6,7 +6,7 @@
|
||||
[subrepo]
|
||||
remote = git@github.com:/Rosalie241/parallel-rdp-standalone.git
|
||||
branch = RMG
|
||||
commit = a81f1a3f0dcd37e2d038433a7397d8b111a568ac
|
||||
parent = 87d1413c99b5b15f8995ff646c12197d34ac9df9
|
||||
commit = 142aed6230b4d5faf05cf25cba711dc0f0a75810
|
||||
parent = 4ab78b79c35f6807fd5194d8fc1d52996c03604e
|
||||
method = merge
|
||||
cmdver = 0.4.6
|
||||
@@ -68,7 +68,6 @@ set(PARALLEL_SOURCES
|
||||
util/aligned_alloc.cpp
|
||||
util/timer.cpp
|
||||
util/timeline_trace_file.cpp
|
||||
util/environment.cpp
|
||||
util/thread_name.cpp
|
||||
volk/volk.c
|
||||
screen.c
|
||||
|
||||
+1
-1
@@ -1 +1 @@
|
||||
43bc31642cc70d04adb828a285e68cdbde7110a9
|
||||
afc61e1050a79b9ab7bb53b8880b055324f7b4a2
|
||||
@@ -33,7 +33,6 @@ PARALLEL_RDP_SOURCES_CXX := \
|
||||
$(PARALLEL_RDP_IMPLEMENTATION)/util/aligned_alloc.cpp \
|
||||
$(PARALLEL_RDP_IMPLEMENTATION)/util/timer.cpp \
|
||||
$(PARALLEL_RDP_IMPLEMENTATION)/util/timeline_trace_file.cpp \
|
||||
$(PARALLEL_RDP_IMPLEMENTATION)/util/environment.cpp \
|
||||
$(PARALLEL_RDP_IMPLEMENTATION)/util/thread_name.cpp
|
||||
|
||||
PARALLEL_RDP_SOURCES_C := \
|
||||
|
||||
-2
@@ -70,9 +70,7 @@ enum StaticRasterizationFlagBits
|
||||
RASTERIZATION_CONVERT_ONE_BIT = 1 << 22,
|
||||
RASTERIZATION_BILERP_0_BIT = 1 << 23,
|
||||
RASTERIZATION_BILERP_1_BIT = 1 << 24,
|
||||
RASTERIZATION_NEED_NOISE_DUAL_BIT = 1 << 25,
|
||||
RASTERIZATION_UPSCALING_LOG2_BIT_OFFSET = 26,
|
||||
// Bit 26 and 27 holds upscaling factor in LOG2.
|
||||
RASTERIZATION_NEED_NOISE_BIT = 1 << 28,
|
||||
RASTERIZATION_USE_STATIC_TEXTURE_SIZE_FORMAT_BIT = 1 << 29,
|
||||
RASTERIZATION_USE_SPECIALIZATION_CONSTANT_BIT = 1 << 30
|
||||
|
||||
@@ -165,38 +165,38 @@ bool Renderer::init_caps()
|
||||
LOGI("Allow small types = %d.\n", int(allow_small_types));
|
||||
}
|
||||
|
||||
if (!features.vk11_features.storageBuffer16BitAccess)
|
||||
if (!features.storage_16bit_features.storageBuffer16BitAccess)
|
||||
{
|
||||
LOGE("16-bit storage for SSBOs is not supported! This is a minimum requirement for paraLLEl-RDP.\n");
|
||||
LOGE("VK_KHR_16bit_storage for SSBOs is not supported! This is a minimum requirement for paraLLEl-RDP.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!features.vk12_features.storageBuffer8BitAccess)
|
||||
if (!features.storage_8bit_features.storageBuffer8BitAccess)
|
||||
{
|
||||
LOGE("8-bit storage for SSBOs is not supported! This is a minimum requirement for paraLLEl-RDP.\n");
|
||||
LOGE("VK_KHR_8bit_storage for SSBOs is not supported! This is a minimum requirement for paraLLEl-RDP.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Driver workarounds here for 8/16-bit integer support.
|
||||
if (features.supports_driver_properties && !forces_small_types)
|
||||
{
|
||||
if (features.driver_id == VK_DRIVER_ID_AMD_PROPRIETARY_KHR)
|
||||
if (features.driver_properties.driverID == VK_DRIVER_ID_AMD_PROPRIETARY_KHR)
|
||||
{
|
||||
LOGW("Current proprietary AMD driver is known to be buggy with 8/16-bit integer arithmetic, disabling support for time being.\n");
|
||||
allow_small_types = false;
|
||||
}
|
||||
else if (features.driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR ||
|
||||
features.driver_id == VK_DRIVER_ID_MESA_RADV_KHR)
|
||||
else if (features.driver_properties.driverID == VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR ||
|
||||
features.driver_properties.driverID == VK_DRIVER_ID_MESA_RADV_KHR)
|
||||
{
|
||||
LOGW("Current open-source AMD drivers are known to be slightly faster without 8/16-bit integer arithmetic.\n");
|
||||
allow_small_types = false;
|
||||
}
|
||||
else if (features.driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR)
|
||||
else if (features.driver_properties.driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR)
|
||||
{
|
||||
LOGW("Current NVIDIA driver is known to be slightly faster without 8/16-bit integer arithmetic.\n");
|
||||
allow_small_types = false;
|
||||
}
|
||||
else if (features.driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR)
|
||||
else if (features.driver_properties.driverID == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR)
|
||||
{
|
||||
LOGW("Current proprietary Intel Windows driver is tested to perform much better without 8/16-bit integer support.\n");
|
||||
allow_small_types = false;
|
||||
@@ -209,7 +209,7 @@ bool Renderer::init_caps()
|
||||
{
|
||||
caps.supports_small_integer_arithmetic = false;
|
||||
}
|
||||
else if (features.enabled_features.shaderInt16 && features.vk12_features.shaderInt8)
|
||||
else if (features.enabled_features.shaderInt16 && features.float16_int8_features.shaderInt8)
|
||||
{
|
||||
LOGI("Enabling 8 and 16-bit integer arithmetic support for more efficient shaders!\n");
|
||||
caps.supports_small_integer_arithmetic = true;
|
||||
@@ -220,7 +220,7 @@ bool Renderer::init_caps()
|
||||
caps.supports_small_integer_arithmetic = false;
|
||||
}
|
||||
|
||||
uint32_t subgroup_size = features.vk11_props.subgroupSize;
|
||||
uint32_t subgroup_size = features.subgroup_properties.subgroupSize;
|
||||
|
||||
const VkSubgroupFeatureFlags required =
|
||||
VK_SUBGROUP_FEATURE_BALLOT_BIT |
|
||||
@@ -230,15 +230,15 @@ bool Renderer::init_caps()
|
||||
|
||||
caps.subgroup_tile_binning =
|
||||
allow_subgroup &&
|
||||
(features.vk11_props.subgroupSupportedOperations & required) == required &&
|
||||
(features.vk11_props.subgroupSupportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0 &&
|
||||
(features.subgroup_properties.supportedOperations & required) == required &&
|
||||
(features.subgroup_properties.supportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0 &&
|
||||
can_support_minimum_subgroup_size(32) && subgroup_size <= 64;
|
||||
|
||||
caps.subgroup_depth_blend =
|
||||
caps.super_sample_readback &&
|
||||
allow_subgroup &&
|
||||
(features.vk11_props.subgroupSupportedOperations & required) == required &&
|
||||
(features.vk11_props.subgroupSupportedOperations & VK_SHADER_STAGE_COMPUTE_BIT) != 0;
|
||||
(features.subgroup_properties.supportedOperations & required) == required &&
|
||||
(features.subgroup_properties.supportedStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0;
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -1131,7 +1131,7 @@ static bool combiner_uses_lod_frac(const StaticRasterizationState &state)
|
||||
void Renderer::deduce_noise_state()
|
||||
{
|
||||
auto &state = stream.static_raster_state;
|
||||
state.flags &= ~(RASTERIZATION_NEED_NOISE_BIT | RASTERIZATION_NEED_NOISE_DUAL_BIT);
|
||||
state.flags &= ~RASTERIZATION_NEED_NOISE_BIT;
|
||||
|
||||
// Figure out if we need to seed noise variable for this primitive.
|
||||
if ((state.dither & 3) == 2 || ((state.dither >> 2) & 3) == 2)
|
||||
@@ -1144,18 +1144,13 @@ void Renderer::deduce_noise_state()
|
||||
return;
|
||||
|
||||
if ((state.flags & RASTERIZATION_MULTI_CYCLE_BIT) != 0)
|
||||
{
|
||||
if (state.combiner[0].rgb.muladd == RGBMulAdd::Noise)
|
||||
state.flags |= RASTERIZATION_NEED_NOISE_BIT;
|
||||
|
||||
if (state.combiner[1].rgb.muladd == RGBMulAdd::Noise)
|
||||
}
|
||||
else if (state.combiner[1].rgb.muladd == RGBMulAdd::Noise)
|
||||
state.flags |= RASTERIZATION_NEED_NOISE_BIT;
|
||||
|
||||
// If both cycles use noise, they need to observe different values.
|
||||
if ((state.flags & RASTERIZATION_MULTI_CYCLE_BIT) != 0 &&
|
||||
state.combiner[0].rgb.muladd == RGBMulAdd::Noise &&
|
||||
state.combiner[1].rgb.muladd == RGBMulAdd::Noise)
|
||||
state.flags |= RASTERIZATION_NEED_NOISE_DUAL_BIT;
|
||||
|
||||
if ((state.flags & (RASTERIZATION_ALPHA_TEST_BIT | RASTERIZATION_ALPHA_TEST_DITHER_BIT)) ==
|
||||
(RASTERIZATION_ALPHA_TEST_BIT | RASTERIZATION_ALPHA_TEST_DITHER_BIT))
|
||||
{
|
||||
@@ -1869,7 +1864,7 @@ void Renderer::submit_tile_binning_combined(Vulkan::CommandBuffer &cmd, bool ups
|
||||
cmd.push_constants(&push, 0, sizeof(push));
|
||||
|
||||
auto &features = device->get_device_features();
|
||||
uint32_t subgroup_size = features.vk11_props.subgroupSize;
|
||||
uint32_t subgroup_size = features.subgroup_properties.subgroupSize;
|
||||
|
||||
Vulkan::QueryPoolHandle start_ts, end_ts;
|
||||
if (caps.timestamp >= 2)
|
||||
@@ -3537,27 +3532,27 @@ void Renderer::set_primitive_color(uint8_t min_level, uint8_t prim_lod_frac, uin
|
||||
|
||||
bool Renderer::can_support_minimum_subgroup_size(unsigned size) const
|
||||
{
|
||||
return supports_subgroup_size_control(size, device->get_device_features().vk11_props.subgroupSize);
|
||||
return supports_subgroup_size_control(size, device->get_device_features().subgroup_properties.subgroupSize);
|
||||
}
|
||||
|
||||
bool Renderer::supports_subgroup_size_control(uint32_t minimum_size, uint32_t maximum_size) const
|
||||
{
|
||||
auto &features = device->get_device_features();
|
||||
|
||||
if (!features.vk13_features.computeFullSubgroups)
|
||||
if (!features.subgroup_size_control_features.computeFullSubgroups)
|
||||
return false;
|
||||
|
||||
bool use_varying = minimum_size <= features.vk13_props.minSubgroupSize &&
|
||||
maximum_size >= features.vk13_props.maxSubgroupSize;
|
||||
bool use_varying = minimum_size <= features.subgroup_size_control_properties.minSubgroupSize &&
|
||||
maximum_size >= features.subgroup_size_control_properties.maxSubgroupSize;
|
||||
|
||||
if (!use_varying)
|
||||
{
|
||||
bool outside_range = minimum_size > features.vk13_props.maxSubgroupSize ||
|
||||
maximum_size < features.vk13_props.minSubgroupSize;
|
||||
bool outside_range = minimum_size > features.subgroup_size_control_properties.maxSubgroupSize ||
|
||||
maximum_size < features.subgroup_size_control_properties.minSubgroupSize;
|
||||
if (outside_range)
|
||||
return false;
|
||||
|
||||
if ((features.vk13_props.requiredSubgroupSizeStages & VK_SHADER_STAGE_COMPUTE_BIT) == 0)
|
||||
if ((features.subgroup_size_control_properties.requiredSubgroupSizeStages & VK_SHADER_STAGE_COMPUTE_BIT) == 0)
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
-1
@@ -61,7 +61,6 @@ const int RASTERIZATION_USES_PIPELINED_TEXEL1_BIT = 1 << 21;
|
||||
const int RASTERIZATION_CONVERT_ONE_BIT = 1 << 22;
|
||||
const int RASTERIZATION_BILERP_0_BIT = 1 << 23;
|
||||
const int RASTERIZATION_BILERP_1_BIT = 1 << 24;
|
||||
const int RASTERIZATION_NEED_NOISE_DUAL_BIT = 1 << 25;
|
||||
const int RASTERIZATION_UPSCALING_LOG2_BIT_OFFSET = 26;
|
||||
const int RASTERIZATION_NEED_NOISE_BIT = 1 << 28;
|
||||
const int RASTERIZATION_USE_STATIC_TEXTURE_SIZE_FORMAT_BIT = 1 << 29;
|
||||
|
||||
@@ -306,14 +306,6 @@ bool shade_pixel(int x, int y, uint primitive_index, out ShadedData shaded)
|
||||
// but let's not go there ...
|
||||
combined_inputs.texel1 = tmp_texel;
|
||||
|
||||
// Resample the noise at some arbitrary other offset.
|
||||
// This only matters if both noise combiner inputs take noise (very weird).
|
||||
if ((static_state_flags & RASTERIZATION_NEED_NOISE_DUAL_BIT) != 0)
|
||||
{
|
||||
reseed_noise(x + 1023, y + 7, primitive_index + global_constants.fb_info.base_primitive_index + 11);
|
||||
combined_inputs.noise = noise_get_combiner();
|
||||
}
|
||||
|
||||
combined = u8x4(combiner_cycle1(combined_inputs,
|
||||
combiner_inputs_rgb1,
|
||||
combiner_inputs_alpha1,
|
||||
|
||||
+48646
-53833
File diff suppressed because it is too large.
Load diff
+8
-9
@@ -38,8 +38,7 @@ void swap(inout uint a, inout uint b)
|
||||
b = tmp;
|
||||
}
|
||||
|
||||
// Workaround Metal using median3.
|
||||
uint Median3(uint left, uint center, uint right)
|
||||
uint median3(uint left, uint center, uint right)
|
||||
{
|
||||
if (left < center)
|
||||
swap(left, center);
|
||||
@@ -66,9 +65,9 @@ void main()
|
||||
else
|
||||
{
|
||||
// Median filter. TODO: Optimize with mid3?
|
||||
uint r = Median3(left.r, mid.r, right.r);
|
||||
uint g = Median3(left.g, mid.g, right.g);
|
||||
uint b = Median3(left.b, mid.b, right.b);
|
||||
uint r = median3(left.r, mid.r, right.r);
|
||||
uint g = median3(left.g, mid.g, right.g);
|
||||
uint b = median3(left.b, mid.b, right.b);
|
||||
FragColor = uvec4(r, g, b, mid.a);
|
||||
}
|
||||
|
||||
@@ -84,10 +83,10 @@ void main()
|
||||
else
|
||||
{
|
||||
// Median filter. TODO: Optimize with mid3?
|
||||
uint r = Median3(left.r, mid.r, right.r);
|
||||
uint g = Median3(left.g, mid.g, right.g);
|
||||
uint b = Median3(left.b, mid.b, right.b);
|
||||
uint r = median3(left.r, mid.r, right.r);
|
||||
uint g = median3(left.g, mid.g, right.g);
|
||||
uint b = median3(left.b, mid.b, right.b);
|
||||
FragColorFetchBug = uvec4(r, g, b, mid.a);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
+6
-6
@@ -807,8 +807,8 @@ Vulkan::ImageHandle VideoInterface::scale_stage(Vulkan::CommandBuffer &cmd, cons
|
||||
{
|
||||
if (prev_image_is_external)
|
||||
{
|
||||
cmd.acquire_image_barrier(*prev_scanout_image, prev_image_layout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
|
||||
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_2_SHADER_SAMPLED_READ_BIT);
|
||||
cmd.acquire_external_image_barrier(*prev_scanout_image, prev_image_layout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
|
||||
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_2_SHADER_SAMPLED_READ_BIT);
|
||||
}
|
||||
else if (prev_image_layout != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
|
||||
{
|
||||
@@ -1396,10 +1396,10 @@ Vulkan::ImageHandle VideoInterface::scanout(VkImageLayout target_layout, const S
|
||||
if (options.export_handle_type != Vulkan::ExternalHandle::get_opaque_memory_handle_type())
|
||||
target_layout = VK_IMAGE_LAYOUT_GENERAL;
|
||||
|
||||
cmd->release_image_barrier(*scale_image, src_layout,
|
||||
target_layout,
|
||||
layout_to_stage(src_layout),
|
||||
layout_to_access(src_layout));
|
||||
cmd->release_external_image_barrier(*scale_image, src_layout,
|
||||
target_layout,
|
||||
layout_to_stage(src_layout),
|
||||
layout_to_access(src_layout));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
@@ -21,7 +21,6 @@
|
||||
*/
|
||||
|
||||
#include "aligned_alloc.hpp"
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
|
||||
@@ -68,130 +68,4 @@ void LegionAllocator::update_longest_run()
|
||||
f &= f >> 1;
|
||||
}
|
||||
}
|
||||
|
||||
bool SliceSubAllocator::allocate_backing_heap(AllocatedSlice *allocation)
|
||||
{
|
||||
uint32_t count = sub_block_size * Util::LegionAllocator::NumSubBlocks;
|
||||
|
||||
if (parent)
|
||||
{
|
||||
return parent->allocate(count, allocation);
|
||||
}
|
||||
else if (global_allocator)
|
||||
{
|
||||
uint32_t index = global_allocator->allocate(count);
|
||||
if (index == UINT32_MAX)
|
||||
return false;
|
||||
|
||||
*allocation = {};
|
||||
allocation->count = count;
|
||||
allocation->buffer_index = index;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void SliceSubAllocator::free_backing_heap(AllocatedSlice *allocation) const
|
||||
{
|
||||
if (parent)
|
||||
parent->free(allocation->heap, allocation->mask);
|
||||
else if (global_allocator)
|
||||
global_allocator->free(allocation->buffer_index);
|
||||
}
|
||||
|
||||
void SliceSubAllocator::prepare_allocation(AllocatedSlice *allocation, Util::IntrusiveList<MiniHeap>::Iterator heap,
|
||||
const Util::SuballocationResult &suballoc)
|
||||
{
|
||||
allocation->buffer_index = heap->allocation.buffer_index;
|
||||
allocation->offset = heap->allocation.offset + suballoc.offset;
|
||||
allocation->count = suballoc.size;
|
||||
allocation->mask = suballoc.mask;
|
||||
allocation->heap = heap;
|
||||
allocation->alloc = this;
|
||||
}
|
||||
|
||||
void SliceAllocator::init(uint32_t sub_block_size, uint32_t num_sub_blocks_in_arena_log2,
|
||||
Util::SliceBackingAllocator *alloc)
|
||||
{
|
||||
global_allocator = alloc;
|
||||
assert(num_sub_blocks_in_arena_log2 < SliceAllocatorCount * 5 && num_sub_blocks_in_arena_log2 >= 5);
|
||||
unsigned num_hierarchies = (num_sub_blocks_in_arena_log2 + 4) / 5;
|
||||
assert(num_hierarchies <= SliceAllocatorCount);
|
||||
|
||||
for (unsigned i = 0; i < num_hierarchies - 1; i++)
|
||||
allocators[i].parent = &allocators[i + 1];
|
||||
allocators[num_hierarchies - 1].global_allocator = alloc;
|
||||
|
||||
unsigned shamt[SliceAllocatorCount] = {};
|
||||
shamt[num_hierarchies - 1] = num_sub_blocks_in_arena_log2 - Util::floor_log2(Util::LegionAllocator::NumSubBlocks);
|
||||
|
||||
// Spread out the multiplier if possible.
|
||||
for (unsigned i = num_hierarchies - 1; i > 1; i--)
|
||||
{
|
||||
shamt[i - 1] = shamt[i] - shamt[i] / (i);
|
||||
assert(shamt[i] - shamt[i - 1] <= Util::floor_log2(Util::LegionAllocator::NumSubBlocks));
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < num_hierarchies; i++)
|
||||
{
|
||||
allocators[i].set_sub_block_size(sub_block_size << shamt[i]);
|
||||
allocators[i].set_object_pool(&object_pool);
|
||||
}
|
||||
}
|
||||
|
||||
void SliceAllocator::free(const Util::AllocatedSlice &slice)
|
||||
{
|
||||
if (slice.alloc)
|
||||
slice.alloc->free(slice.heap, slice.mask);
|
||||
else if (slice.buffer_index != UINT32_MAX)
|
||||
global_allocator->free(slice.buffer_index);
|
||||
}
|
||||
|
||||
void SliceAllocator::prime(const void *opaque_meta)
|
||||
{
|
||||
for (auto &alloc : allocators)
|
||||
{
|
||||
if (alloc.global_allocator)
|
||||
{
|
||||
alloc.global_allocator->prime(alloc.get_sub_block_size() * Util::LegionAllocator::NumSubBlocks, opaque_meta);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool SliceAllocator::allocate(uint32_t count, Util::AllocatedSlice *slice)
|
||||
{
|
||||
for (auto &alloc : allocators)
|
||||
{
|
||||
uint32_t max_alloc_size = alloc.get_max_allocation_size();
|
||||
if (count <= max_alloc_size)
|
||||
return alloc.allocate(count, slice);
|
||||
}
|
||||
|
||||
LOGE("Allocation of %u elements is too large for SliceAllocator.\n", count);
|
||||
return false;
|
||||
}
|
||||
|
||||
void SliceBackingAllocatorVA::free(uint32_t)
|
||||
{
|
||||
allocated = false;
|
||||
}
|
||||
|
||||
uint32_t SliceBackingAllocatorVA::allocate(uint32_t)
|
||||
{
|
||||
if (allocated)
|
||||
return UINT32_MAX;
|
||||
else
|
||||
{
|
||||
allocated = true;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void SliceBackingAllocatorVA::prime(uint32_t, const void *)
|
||||
{
|
||||
}
|
||||
}
|
||||
@@ -98,13 +98,6 @@ struct AllocationArena
|
||||
uint32_t heap_availability_mask = 0;
|
||||
};
|
||||
|
||||
struct SuballocationResult
|
||||
{
|
||||
uint32_t offset;
|
||||
uint32_t size;
|
||||
uint32_t mask;
|
||||
};
|
||||
|
||||
template <typename DerivedAllocator, typename BackingAllocation>
|
||||
class ArenaAllocator
|
||||
{
|
||||
@@ -138,14 +131,9 @@ public:
|
||||
return sub_block_size * Util::LegionAllocator::NumSubBlocks;
|
||||
}
|
||||
|
||||
inline uint32_t get_sub_block_size() const
|
||||
{
|
||||
return sub_block_size;
|
||||
}
|
||||
|
||||
inline uint32_t get_block_alignment() const
|
||||
{
|
||||
return get_sub_block_size();
|
||||
return sub_block_size;
|
||||
}
|
||||
|
||||
inline bool allocate(uint32_t size, BackingAllocation *alloc)
|
||||
@@ -161,7 +149,7 @@ public:
|
||||
assert(index >= (num_blocks - 1));
|
||||
|
||||
auto &heap = *itr;
|
||||
static_cast<DerivedAllocator *>(this)->prepare_allocation(alloc, itr, suballocate(num_blocks, heap));
|
||||
static_cast<DerivedAllocator *>(this)->prepare_allocation(alloc, heap, suballocate(num_blocks, heap));
|
||||
|
||||
unsigned new_index = heap.heap.get_longest_run() - 1;
|
||||
|
||||
@@ -180,6 +168,7 @@ public:
|
||||
heap_arena.heap_availability_mask &= ~(1u << index);
|
||||
}
|
||||
|
||||
alloc->heap = itr;
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -197,8 +186,9 @@ public:
|
||||
}
|
||||
|
||||
// This cannot fail.
|
||||
static_cast<DerivedAllocator *>(this)->prepare_allocation(alloc, node, suballocate(num_blocks, heap));
|
||||
static_cast<DerivedAllocator *>(this)->prepare_allocation(alloc, heap, suballocate(num_blocks, heap));
|
||||
|
||||
alloc->heap = node;
|
||||
if (heap.heap.full())
|
||||
{
|
||||
heap_arena.full_heaps.insert_front(node);
|
||||
@@ -264,6 +254,13 @@ protected:
|
||||
uint32_t sub_block_size = 1;
|
||||
uint32_t sub_block_size_log2 = 0;
|
||||
|
||||
struct SuballocationResult
|
||||
{
|
||||
uint32_t offset;
|
||||
uint32_t size;
|
||||
uint32_t mask;
|
||||
};
|
||||
|
||||
private:
|
||||
inline SuballocationResult suballocate(uint32_t num_blocks, MiniHeap &heap)
|
||||
{
|
||||
@@ -274,63 +271,4 @@ private:
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
struct SliceSubAllocator;
|
||||
|
||||
struct AllocatedSlice
|
||||
{
|
||||
uint32_t buffer_index = UINT32_MAX;
|
||||
uint32_t offset = 0;
|
||||
uint32_t count = 0;
|
||||
uint32_t mask = 0;
|
||||
|
||||
SliceSubAllocator *alloc = nullptr;
|
||||
Util::IntrusiveList<Util::LegionHeap<AllocatedSlice>>::Iterator heap = {};
|
||||
};
|
||||
|
||||
struct SliceBackingAllocator
|
||||
{
|
||||
virtual ~SliceBackingAllocator() = default;
|
||||
virtual uint32_t allocate(uint32_t count) = 0;
|
||||
virtual void free(uint32_t index) = 0;
|
||||
virtual void prime(uint32_t count, const void *opaque_meta) = 0;
|
||||
};
|
||||
|
||||
struct SliceBackingAllocatorVA : SliceBackingAllocator
|
||||
{
|
||||
uint32_t allocate(uint32_t count) override;
|
||||
void free(uint32_t index) override;
|
||||
void prime(uint32_t count, const void *opaque_meta) override;
|
||||
bool allocated = false;
|
||||
};
|
||||
|
||||
struct SliceSubAllocator : Util::ArenaAllocator<SliceSubAllocator, AllocatedSlice>
|
||||
{
|
||||
SliceSubAllocator *parent = nullptr;
|
||||
SliceBackingAllocator *global_allocator = nullptr;
|
||||
|
||||
// Implements curious recurring template pattern calls.
|
||||
bool allocate_backing_heap(AllocatedSlice *allocation);
|
||||
void free_backing_heap(AllocatedSlice *allocation) const;
|
||||
void prepare_allocation(AllocatedSlice *allocation, Util::IntrusiveList<MiniHeap>::Iterator heap,
|
||||
const Util::SuballocationResult &suballoc);
|
||||
};
|
||||
|
||||
class SliceAllocator
|
||||
{
|
||||
public:
|
||||
bool allocate(uint32_t count, Util::AllocatedSlice *slice);
|
||||
void free(const Util::AllocatedSlice &slice);
|
||||
void prime(const void *opaque_meta);
|
||||
|
||||
protected:
|
||||
SliceAllocator() = default;
|
||||
void init(uint32_t sub_block_size, uint32_t num_sub_blocks_in_arena_log2, SliceBackingAllocator *alloc);
|
||||
|
||||
private:
|
||||
Util::ObjectPool<Util::LegionHeap<Util::AllocatedSlice>> object_pool;
|
||||
SliceBackingAllocator *global_allocator = nullptr;
|
||||
enum { SliceAllocatorCount = 5 };
|
||||
Util::SliceSubAllocator allocators[SliceAllocatorCount];
|
||||
};
|
||||
}
|
||||
@@ -35,15 +35,9 @@ namespace Util
|
||||
#define leading_zeroes64(x) ((x) == 0 ? 64 : __builtin_clzll(x))
|
||||
#define trailing_zeroes64(x) ((x) == 0 ? 64 : __builtin_ctzll(x))
|
||||
#define trailing_ones64(x) __builtin_ctzll(~uint64_t(x))
|
||||
#define popcount32(x) __builtin_popcount(x)
|
||||
#elif defined(_MSC_VER)
|
||||
namespace Internal
|
||||
{
|
||||
static inline uint32_t popcount32(uint32_t x)
|
||||
{
|
||||
return __popcnt(x);
|
||||
}
|
||||
|
||||
static inline uint32_t clz(uint32_t x)
|
||||
{
|
||||
unsigned long result;
|
||||
@@ -81,7 +75,6 @@ static inline uint32_t ctz64(uint64_t x)
|
||||
}
|
||||
}
|
||||
|
||||
#define popcount32(x) ::Util::Internal::popcount32(x)
|
||||
#define leading_zeroes(x) ::Util::Internal::clz(x)
|
||||
#define trailing_zeroes(x) ::Util::Internal::ctz(x)
|
||||
#define trailing_ones(x) ::Util::Internal::ctz(~uint32_t(x))
|
||||
|
||||
@@ -1,59 +0,0 @@
|
||||
/* Copyright (c) 2017-2023 Hans-Kristian Arntzen
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be
|
||||
* included in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "aligned_alloc.hpp"
|
||||
#include <memory>
|
||||
#include <algorithm>
|
||||
#include <type_traits>
|
||||
|
||||
namespace Util
|
||||
{
|
||||
template <typename T>
|
||||
class DynamicArray
|
||||
{
|
||||
public:
|
||||
// Only POD-like types work here since we don't invoke placement new or delete.
|
||||
static_assert(std::is_trivially_default_constructible<T>::value, "T must be trivially constructible.");
|
||||
static_assert(std::is_trivially_destructible<T>::value, "T must be trivially destructible.");
|
||||
|
||||
inline void reserve(size_t n)
|
||||
{
|
||||
if (n > N)
|
||||
{
|
||||
buffer.reset(static_cast<T *>(memalign_alloc(std::max<size_t>(64, alignof(T)), n * sizeof(T))));
|
||||
N = n;
|
||||
}
|
||||
}
|
||||
|
||||
inline T &operator[](size_t index) { return buffer.get()[index]; }
|
||||
inline const T &operator[](size_t index) const { return buffer.get()[index]; }
|
||||
inline T *data() { return buffer.get(); }
|
||||
inline const T *data() const { return buffer.get(); }
|
||||
inline size_t get_capacity() const { return N; }
|
||||
|
||||
private:
|
||||
std::unique_ptr<T, AlignedDeleter> buffer;
|
||||
size_t N = 0;
|
||||
};
|
||||
}
|
||||
@@ -1,96 +0,0 @@
|
||||
/* Copyright (c) 2017-2023 Hans-Kristian Arntzen
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be
|
||||
* included in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifdef _WIN32
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
#include "environment.hpp"
|
||||
#include <string>
|
||||
#include <stdlib.h>
|
||||
|
||||
namespace Util
|
||||
{
|
||||
bool get_environment(const char *env, std::string &str)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
char buf[4096];
|
||||
DWORD count = GetEnvironmentVariableA(env, buf, sizeof(buf));
|
||||
if (count)
|
||||
{
|
||||
str = { buf, buf + count };
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
#else
|
||||
if (const char *v = getenv(env))
|
||||
{
|
||||
str = v;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
void set_environment(const char *env, const char *value)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
SetEnvironmentVariableA(env, value);
|
||||
#else
|
||||
setenv(env, value, 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
std::string get_environment_string(const char *env, const char *default_value)
|
||||
{
|
||||
std::string v;
|
||||
if (!get_environment(env, v))
|
||||
v = default_value;
|
||||
return v;
|
||||
}
|
||||
|
||||
unsigned get_environment_uint(const char *env, unsigned default_value)
|
||||
{
|
||||
unsigned value = default_value;
|
||||
std::string v;
|
||||
if (get_environment(env, v))
|
||||
value = unsigned(std::stoul(v));
|
||||
return value;
|
||||
}
|
||||
|
||||
int get_environment_int(const char *env, int default_value)
|
||||
{
|
||||
int value = default_value;
|
||||
std::string v;
|
||||
if (get_environment(env, v))
|
||||
value = int(std::stol(v));
|
||||
return value;
|
||||
}
|
||||
|
||||
bool get_environment_bool(const char *env, bool default_value)
|
||||
{
|
||||
return get_environment_int(env, int(default_value)) != 0;
|
||||
}
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/* Copyright (c) 2017-2023 Hans-Kristian Arntzen
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be
|
||||
* included in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace Util
|
||||
{
|
||||
bool get_environment(const char *env, std::string &str);
|
||||
std::string get_environment_string(const char *env, const char *default_value);
|
||||
unsigned get_environment_uint(const char *env, unsigned default_value);
|
||||
int get_environment_int(const char *env, int default_value);
|
||||
bool get_environment_bool(const char *env, bool default_value);
|
||||
void set_environment(const char *env, const char *value);
|
||||
}
|
||||
@@ -72,13 +72,9 @@ public:
|
||||
{
|
||||
for (auto &ring : rings)
|
||||
{
|
||||
while (!ring.empty())
|
||||
{
|
||||
auto itr = ring.begin();
|
||||
ring.erase(itr);
|
||||
auto &node = *itr;
|
||||
for (auto &node : ring)
|
||||
object_pool.free(static_cast<T *>(&node));
|
||||
}
|
||||
ring.clear();
|
||||
}
|
||||
hashmap.clear();
|
||||
|
||||
@@ -91,16 +87,12 @@ public:
|
||||
void begin_frame()
|
||||
{
|
||||
index = (index + 1) & (RingSize - 1);
|
||||
auto &ring = rings[index];
|
||||
|
||||
while (!ring.empty())
|
||||
for (auto &node : rings[index])
|
||||
{
|
||||
auto itr = ring.begin();
|
||||
ring.erase(itr);
|
||||
auto &node = *itr;
|
||||
hashmap.erase(node.get_hash());
|
||||
free_object(&node, ReuseTag<ReuseObjects>());
|
||||
}
|
||||
rings[index].clear();
|
||||
}
|
||||
|
||||
T *request(Hash hash)
|
||||
|
||||
@@ -22,38 +22,19 @@
|
||||
|
||||
#include "thread_name.hpp"
|
||||
|
||||
#if !defined(_WIN32)
|
||||
#ifdef __linux__
|
||||
#include <pthread.h>
|
||||
#else
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
#include <string>
|
||||
#endif
|
||||
|
||||
namespace Util
|
||||
{
|
||||
void set_current_thread_name(const char *name)
|
||||
{
|
||||
#if defined(__linux__)
|
||||
#ifdef __linux__
|
||||
pthread_setname_np(pthread_self(), name);
|
||||
#elif defined(__APPLE__)
|
||||
pthread_setname_np(name);
|
||||
#elif defined(_WIN32)
|
||||
using PFN_SetThreadDescription = HRESULT (WINAPI *)(HANDLE, PCWSTR);
|
||||
auto module = GetModuleHandleA("kernel32.dll");
|
||||
PFN_SetThreadDescription SetThreadDescription = module ? reinterpret_cast<PFN_SetThreadDescription>(
|
||||
(void *)GetProcAddress(module, "SetThreadDescription")) : nullptr;
|
||||
|
||||
if (SetThreadDescription)
|
||||
{
|
||||
std::wstring wname;
|
||||
while (*name != '\0')
|
||||
{
|
||||
wname.push_back(*name);
|
||||
name++;
|
||||
}
|
||||
SetThreadDescription(GetCurrentThread(), wname.c_str());
|
||||
}
|
||||
#else
|
||||
// TODO: Kinda messy.
|
||||
(void)name;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -150,11 +150,11 @@ TimelineTraceFile::~TimelineTraceFile()
|
||||
thr.join();
|
||||
}
|
||||
|
||||
TimelineTraceFile::ScopedEvent::ScopedEvent(TimelineTraceFile *file_, const char *tag, uint32_t pid)
|
||||
TimelineTraceFile::ScopedEvent::ScopedEvent(TimelineTraceFile *file_, const char *tag)
|
||||
: file(file_)
|
||||
{
|
||||
if (file && tag && *tag != '\0')
|
||||
event = file->begin_event(tag, pid);
|
||||
event = file->begin_event(tag);
|
||||
}
|
||||
|
||||
TimelineTraceFile::ScopedEvent::~ScopedEvent()
|
||||
@@ -162,24 +162,4 @@ TimelineTraceFile::ScopedEvent::~ScopedEvent()
|
||||
if (event)
|
||||
file->end_event(event);
|
||||
}
|
||||
|
||||
TimelineTraceFile::ScopedEvent &
|
||||
TimelineTraceFile::ScopedEvent::operator=(TimelineTraceFile::ScopedEvent &&other) noexcept
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
if (event)
|
||||
file->end_event(event);
|
||||
event = other.event;
|
||||
file = other.file;
|
||||
other.event = nullptr;
|
||||
other.file = nullptr;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
TimelineTraceFile::ScopedEvent::ScopedEvent(TimelineTraceFile::ScopedEvent &&other) noexcept
|
||||
{
|
||||
*this = std::move(other);
|
||||
}
|
||||
}
|
||||
@@ -60,13 +60,10 @@ public:
|
||||
|
||||
struct ScopedEvent
|
||||
{
|
||||
ScopedEvent(TimelineTraceFile *file, const char *tag, uint32_t pid = 0);
|
||||
ScopedEvent() = default;
|
||||
ScopedEvent(TimelineTraceFile *file, const char *tag);
|
||||
~ScopedEvent();
|
||||
void operator=(const ScopedEvent &) = delete;
|
||||
ScopedEvent(const ScopedEvent &) = delete;
|
||||
ScopedEvent(ScopedEvent &&other) noexcept;
|
||||
ScopedEvent &operator=(ScopedEvent &&other) noexcept;
|
||||
TimelineTraceFile *file = nullptr;
|
||||
Event *event = nullptr;
|
||||
};
|
||||
@@ -82,13 +79,10 @@ private:
|
||||
};
|
||||
|
||||
#ifndef GRANITE_SHIPPING
|
||||
|
||||
#define GRANITE_MACRO_CONCAT_IMPL(a, b) a##b
|
||||
#define GRANITE_MACRO_CONCAT(a, b) GRANITE_MACRO_CONCAT_IMPL(a, b)
|
||||
#define GRANITE_SCOPED_TIMELINE_EVENT(str) \
|
||||
::Util::TimelineTraceFile::ScopedEvent GRANITE_MACRO_CONCAT(_timeline_scoped_count_, __COUNTER__){GRANITE_THREAD_GROUP() ? GRANITE_THREAD_GROUP()->get_timeline_trace_file() : nullptr, str}
|
||||
::Util::TimelineTraceFile::ScopedEvent _timeline_scoped_count_##__COUNTER__{GRANITE_THREAD_GROUP()->get_timeline_trace_file(), str}
|
||||
#define GRANITE_SCOPED_TIMELINE_EVENT_FILE(file, str) \
|
||||
::Util::TimelineTraceFile::ScopedEvent GRANITE_MACRO_CONCAT(_timeline_scoped_count_, __COUNTER__){file, str}
|
||||
::Util::TimelineTraceFile::ScopedEvent _timeline_scoped_count_##__COUNTER__{file, str}
|
||||
#else
|
||||
#define GRANITE_SCOPED_TIMELINE_EVENT(...) ((void)0)
|
||||
#define GRANITE_SCOPED_TIMELINE_EVENT_FILE(...) ((void)0)
|
||||
|
||||
+189
-459
File diff suppressed because it is too large.
Load diff
+129
-305
@@ -1,7 +1,7 @@
|
||||
/**
|
||||
* volk
|
||||
*
|
||||
* Copyright (C) 2018-2023, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
|
||||
* Copyright (C) 2018-2022, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
|
||||
* Report bugs and download new versions at https://github.com/zeux/volk
|
||||
*
|
||||
* This library is distributed under the MIT License. See notice at the end of this file.
|
||||
@@ -15,7 +15,7 @@
|
||||
#endif
|
||||
|
||||
/* VOLK_GENERATE_VERSION_DEFINE */
|
||||
#define VOLK_HEADER_VERSION 269
|
||||
#define VOLK_HEADER_VERSION 238
|
||||
/* VOLK_GENERATE_VERSION_DEFINE */
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
@@ -23,8 +23,8 @@
|
||||
#endif
|
||||
|
||||
#ifndef VULKAN_H_
|
||||
# ifdef VOLK_VULKAN_H_PATH
|
||||
# include VOLK_VULKAN_H_PATH
|
||||
# ifdef VOLK_VULKAN_H_PATH
|
||||
# include VOLK_VULKAN_H_PATH
|
||||
# elif defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
# include <vulkan/vk_platform.h>
|
||||
# include <vulkan/vulkan_core.h>
|
||||
@@ -323,15 +323,6 @@ struct VolkDeviceTable
|
||||
PFN_vkQueueSubmit2 vkQueueSubmit2;
|
||||
PFN_vkSetPrivateData vkSetPrivateData;
|
||||
#endif /* defined(VK_VERSION_1_3) */
|
||||
#if defined(VK_AMDX_shader_enqueue)
|
||||
PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX;
|
||||
PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX;
|
||||
PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX;
|
||||
PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX;
|
||||
PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX;
|
||||
PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX;
|
||||
PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX;
|
||||
#endif /* defined(VK_AMDX_shader_enqueue) */
|
||||
#if defined(VK_AMD_buffer_marker)
|
||||
PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD;
|
||||
#endif /* defined(VK_AMD_buffer_marker) */
|
||||
@@ -349,9 +340,6 @@ struct VolkDeviceTable
|
||||
PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID;
|
||||
PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID;
|
||||
#endif /* defined(VK_ANDROID_external_memory_android_hardware_buffer) */
|
||||
#if defined(VK_EXT_attachment_feedback_loop_dynamic_state)
|
||||
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT;
|
||||
#endif /* defined(VK_EXT_attachment_feedback_loop_dynamic_state) */
|
||||
#if defined(VK_EXT_buffer_device_address)
|
||||
PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT;
|
||||
#endif /* defined(VK_EXT_buffer_device_address) */
|
||||
@@ -372,9 +360,6 @@ struct VolkDeviceTable
|
||||
PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT;
|
||||
PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT;
|
||||
#endif /* defined(VK_EXT_debug_marker) */
|
||||
#if defined(VK_EXT_depth_bias_control)
|
||||
PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT;
|
||||
#endif /* defined(VK_EXT_depth_bias_control) */
|
||||
#if defined(VK_EXT_descriptor_buffer)
|
||||
PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT;
|
||||
PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT;
|
||||
@@ -387,25 +372,75 @@ struct VolkDeviceTable
|
||||
PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT;
|
||||
PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT;
|
||||
#endif /* defined(VK_EXT_descriptor_buffer) */
|
||||
#if defined(VK_EXT_descriptor_buffer) && (defined(VK_KHR_acceleration_structure) || defined(VK_NV_ray_tracing))
|
||||
#if defined(VK_EXT_descriptor_buffer) && defined(VK_KHR_acceleration_structure) && defined(VK_NV_ray_tracing)
|
||||
PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT;
|
||||
#endif /* defined(VK_EXT_descriptor_buffer) && (defined(VK_KHR_acceleration_structure) || defined(VK_NV_ray_tracing)) */
|
||||
#endif /* defined(VK_EXT_descriptor_buffer) && defined(VK_KHR_acceleration_structure) && defined(VK_NV_ray_tracing) */
|
||||
#if defined(VK_EXT_device_fault)
|
||||
PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT;
|
||||
#endif /* defined(VK_EXT_device_fault) */
|
||||
#if defined(VK_EXT_discard_rectangles)
|
||||
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT;
|
||||
#endif /* defined(VK_EXT_discard_rectangles) */
|
||||
#if defined(VK_EXT_discard_rectangles) && VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION >= 2
|
||||
PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT;
|
||||
PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT;
|
||||
#endif /* defined(VK_EXT_discard_rectangles) && VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION >= 2 */
|
||||
#if defined(VK_EXT_display_control)
|
||||
PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT;
|
||||
PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT;
|
||||
PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT;
|
||||
PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT;
|
||||
#endif /* defined(VK_EXT_display_control) */
|
||||
#if defined(VK_EXT_extended_dynamic_state)
|
||||
PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT;
|
||||
PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT;
|
||||
PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT;
|
||||
PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT;
|
||||
PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT;
|
||||
PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT;
|
||||
PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT;
|
||||
PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT;
|
||||
PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT;
|
||||
PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT;
|
||||
PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT;
|
||||
PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT;
|
||||
#endif /* defined(VK_EXT_extended_dynamic_state) */
|
||||
#if defined(VK_EXT_extended_dynamic_state2)
|
||||
PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT;
|
||||
PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT;
|
||||
PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT;
|
||||
PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT;
|
||||
PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT;
|
||||
#endif /* defined(VK_EXT_extended_dynamic_state2) */
|
||||
#if defined(VK_EXT_extended_dynamic_state3)
|
||||
PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
|
||||
PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
|
||||
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
|
||||
PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
|
||||
PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
|
||||
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV;
|
||||
PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV;
|
||||
PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV;
|
||||
PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV;
|
||||
PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV;
|
||||
PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV;
|
||||
PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
|
||||
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
|
||||
PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
|
||||
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
|
||||
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV;
|
||||
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
|
||||
PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV;
|
||||
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV;
|
||||
PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
|
||||
#endif /* defined(VK_EXT_extended_dynamic_state3) */
|
||||
#if defined(VK_EXT_external_memory_host)
|
||||
PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT;
|
||||
#endif /* defined(VK_EXT_external_memory_host) */
|
||||
@@ -416,15 +451,12 @@ struct VolkDeviceTable
|
||||
#if defined(VK_EXT_hdr_metadata)
|
||||
PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT;
|
||||
#endif /* defined(VK_EXT_hdr_metadata) */
|
||||
#if defined(VK_EXT_host_image_copy)
|
||||
PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT;
|
||||
PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT;
|
||||
PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT;
|
||||
PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT;
|
||||
#endif /* defined(VK_EXT_host_image_copy) */
|
||||
#if defined(VK_EXT_host_query_reset)
|
||||
PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT;
|
||||
#endif /* defined(VK_EXT_host_query_reset) */
|
||||
#if defined(VK_EXT_image_compression_control)
|
||||
PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT;
|
||||
#endif /* defined(VK_EXT_image_compression_control) */
|
||||
#if defined(VK_EXT_image_drm_format_modifier)
|
||||
PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT;
|
||||
#endif /* defined(VK_EXT_image_drm_format_modifier) */
|
||||
@@ -478,12 +510,6 @@ struct VolkDeviceTable
|
||||
PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT;
|
||||
PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT;
|
||||
#endif /* defined(VK_EXT_shader_module_identifier) */
|
||||
#if defined(VK_EXT_shader_object)
|
||||
PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT;
|
||||
PFN_vkCreateShadersEXT vkCreateShadersEXT;
|
||||
PFN_vkDestroyShaderEXT vkDestroyShaderEXT;
|
||||
PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT;
|
||||
#endif /* defined(VK_EXT_shader_object) */
|
||||
#if defined(VK_EXT_swapchain_maintenance1)
|
||||
PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT;
|
||||
#endif /* defined(VK_EXT_swapchain_maintenance1) */
|
||||
@@ -501,6 +527,9 @@ struct VolkDeviceTable
|
||||
PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT;
|
||||
PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT;
|
||||
#endif /* defined(VK_EXT_validation_cache) */
|
||||
#if defined(VK_EXT_vertex_input_dynamic_state)
|
||||
PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT;
|
||||
#endif /* defined(VK_EXT_vertex_input_dynamic_state) */
|
||||
#if defined(VK_FUCHSIA_buffer_collection)
|
||||
PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA;
|
||||
PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA;
|
||||
@@ -520,10 +549,6 @@ struct VolkDeviceTable
|
||||
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE;
|
||||
PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE;
|
||||
#endif /* defined(VK_GOOGLE_display_timing) */
|
||||
#if defined(VK_HUAWEI_cluster_culling_shader)
|
||||
PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI;
|
||||
PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI;
|
||||
#endif /* defined(VK_HUAWEI_cluster_culling_shader) */
|
||||
#if defined(VK_HUAWEI_invocation_mask)
|
||||
PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI;
|
||||
#endif /* defined(VK_HUAWEI_invocation_mask) */
|
||||
@@ -654,16 +679,6 @@ struct VolkDeviceTable
|
||||
PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR;
|
||||
PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR;
|
||||
#endif /* defined(VK_KHR_maintenance4) */
|
||||
#if defined(VK_KHR_maintenance5)
|
||||
PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR;
|
||||
PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR;
|
||||
PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR;
|
||||
PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR;
|
||||
#endif /* defined(VK_KHR_maintenance5) */
|
||||
#if defined(VK_KHR_map_memory2)
|
||||
PFN_vkMapMemory2KHR vkMapMemory2KHR;
|
||||
PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR;
|
||||
#endif /* defined(VK_KHR_map_memory2) */
|
||||
#if defined(VK_KHR_performance_query)
|
||||
PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR;
|
||||
PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR;
|
||||
@@ -729,7 +744,6 @@ struct VolkDeviceTable
|
||||
#endif /* defined(VK_KHR_video_decode_queue) */
|
||||
#if defined(VK_KHR_video_encode_queue)
|
||||
PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR;
|
||||
PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR;
|
||||
#endif /* defined(VK_KHR_video_encode_queue) */
|
||||
#if defined(VK_KHR_video_queue)
|
||||
PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR;
|
||||
@@ -761,14 +775,6 @@ struct VolkDeviceTable
|
||||
PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV;
|
||||
PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV;
|
||||
#endif /* defined(VK_NV_copy_memory_indirect) */
|
||||
#if defined(VK_NV_cuda_kernel_launch)
|
||||
PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV;
|
||||
PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV;
|
||||
PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV;
|
||||
PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV;
|
||||
PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV;
|
||||
PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV;
|
||||
#endif /* defined(VK_NV_cuda_kernel_launch) */
|
||||
#if defined(VK_NV_device_diagnostic_checkpoints)
|
||||
PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV;
|
||||
PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV;
|
||||
@@ -781,11 +787,6 @@ struct VolkDeviceTable
|
||||
PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV;
|
||||
PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV;
|
||||
#endif /* defined(VK_NV_device_generated_commands) */
|
||||
#if defined(VK_NV_device_generated_commands_compute)
|
||||
PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV;
|
||||
PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV;
|
||||
PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV;
|
||||
#endif /* defined(VK_NV_device_generated_commands_compute) */
|
||||
#if defined(VK_NV_external_memory_rdma)
|
||||
PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV;
|
||||
#endif /* defined(VK_NV_external_memory_rdma) */
|
||||
@@ -795,13 +796,6 @@ struct VolkDeviceTable
|
||||
#if defined(VK_NV_fragment_shading_rate_enums)
|
||||
PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV;
|
||||
#endif /* defined(VK_NV_fragment_shading_rate_enums) */
|
||||
#if defined(VK_NV_low_latency2)
|
||||
PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV;
|
||||
PFN_vkLatencySleepNV vkLatencySleepNV;
|
||||
PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV;
|
||||
PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV;
|
||||
PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV;
|
||||
#endif /* defined(VK_NV_low_latency2) */
|
||||
#if defined(VK_NV_memory_decompression)
|
||||
PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV;
|
||||
PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV;
|
||||
@@ -831,9 +825,6 @@ struct VolkDeviceTable
|
||||
PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV;
|
||||
PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV;
|
||||
#endif /* defined(VK_NV_ray_tracing) */
|
||||
#if defined(VK_NV_scissor_exclusive) && VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION >= 2
|
||||
PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV;
|
||||
#endif /* defined(VK_NV_scissor_exclusive) && VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION >= 2 */
|
||||
#if defined(VK_NV_scissor_exclusive)
|
||||
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV;
|
||||
#endif /* defined(VK_NV_scissor_exclusive) */
|
||||
@@ -846,90 +837,13 @@ struct VolkDeviceTable
|
||||
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM;
|
||||
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM;
|
||||
#endif /* defined(VK_QCOM_tile_properties) */
|
||||
#if defined(VK_QNX_external_memory_screen_buffer)
|
||||
PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX;
|
||||
#endif /* defined(VK_QNX_external_memory_screen_buffer) */
|
||||
#if defined(VK_VALVE_descriptor_set_host_mapping)
|
||||
PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE;
|
||||
PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE;
|
||||
#endif /* defined(VK_VALVE_descriptor_set_host_mapping) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object))
|
||||
PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT;
|
||||
PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT;
|
||||
PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT;
|
||||
PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT;
|
||||
PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT;
|
||||
PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT;
|
||||
PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT;
|
||||
PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT;
|
||||
PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT;
|
||||
PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT;
|
||||
PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT;
|
||||
PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object))
|
||||
PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT;
|
||||
PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT;
|
||||
PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT;
|
||||
PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT;
|
||||
PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
|
||||
PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
|
||||
PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
|
||||
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
|
||||
PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
|
||||
PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
|
||||
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
|
||||
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
|
||||
PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
|
||||
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
|
||||
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
|
||||
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
|
||||
PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_viewport_swizzle)) || (defined(VK_EXT_shader_object) && defined(VK_NV_viewport_swizzle))
|
||||
PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_viewport_swizzle)) || (defined(VK_EXT_shader_object) && defined(VK_NV_viewport_swizzle)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_fragment_coverage_to_color)) || (defined(VK_EXT_shader_object) && defined(VK_NV_fragment_coverage_to_color))
|
||||
PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV;
|
||||
PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_fragment_coverage_to_color)) || (defined(VK_EXT_shader_object) && defined(VK_NV_fragment_coverage_to_color)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_framebuffer_mixed_samples)) || (defined(VK_EXT_shader_object) && defined(VK_NV_framebuffer_mixed_samples))
|
||||
PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV;
|
||||
PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV;
|
||||
PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_framebuffer_mixed_samples)) || (defined(VK_EXT_shader_object) && defined(VK_NV_framebuffer_mixed_samples)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_shading_rate_image)) || (defined(VK_EXT_shader_object) && defined(VK_NV_shading_rate_image))
|
||||
PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_shading_rate_image)) || (defined(VK_EXT_shader_object) && defined(VK_NV_shading_rate_image)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_representative_fragment_test)) || (defined(VK_EXT_shader_object) && defined(VK_NV_representative_fragment_test))
|
||||
PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_representative_fragment_test)) || (defined(VK_EXT_shader_object) && defined(VK_NV_representative_fragment_test)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_coverage_reduction_mode)) || (defined(VK_EXT_shader_object) && defined(VK_NV_coverage_reduction_mode))
|
||||
PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_coverage_reduction_mode)) || (defined(VK_EXT_shader_object) && defined(VK_NV_coverage_reduction_mode)) */
|
||||
#if (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1))
|
||||
PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT;
|
||||
#endif /* (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1)) */
|
||||
#if (defined(VK_EXT_host_image_copy)) || (defined(VK_EXT_image_compression_control))
|
||||
PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT;
|
||||
#endif /* (defined(VK_EXT_host_image_copy)) || (defined(VK_EXT_image_compression_control)) */
|
||||
#if (defined(VK_EXT_shader_object)) || (defined(VK_EXT_vertex_input_dynamic_state))
|
||||
PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT;
|
||||
#endif /* (defined(VK_EXT_shader_object)) || (defined(VK_EXT_vertex_input_dynamic_state)) */
|
||||
#if (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) || (defined(VK_KHR_push_descriptor) && defined(VK_KHR_descriptor_update_template))
|
||||
PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR;
|
||||
#endif /* (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) || (defined(VK_KHR_push_descriptor) && defined(VK_KHR_descriptor_update_template)) */
|
||||
@@ -1167,15 +1081,6 @@ extern PFN_vkGetPrivateData vkGetPrivateData;
|
||||
extern PFN_vkQueueSubmit2 vkQueueSubmit2;
|
||||
extern PFN_vkSetPrivateData vkSetPrivateData;
|
||||
#endif /* defined(VK_VERSION_1_3) */
|
||||
#if defined(VK_AMDX_shader_enqueue)
|
||||
extern PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX;
|
||||
extern PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX;
|
||||
extern PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX;
|
||||
extern PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX;
|
||||
extern PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX;
|
||||
extern PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX;
|
||||
extern PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX;
|
||||
#endif /* defined(VK_AMDX_shader_enqueue) */
|
||||
#if defined(VK_AMD_buffer_marker)
|
||||
extern PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD;
|
||||
#endif /* defined(VK_AMD_buffer_marker) */
|
||||
@@ -1201,9 +1106,6 @@ extern PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT;
|
||||
extern PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT;
|
||||
extern PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT;
|
||||
#endif /* defined(VK_EXT_acquire_xlib_display) */
|
||||
#if defined(VK_EXT_attachment_feedback_loop_dynamic_state)
|
||||
extern PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT;
|
||||
#endif /* defined(VK_EXT_attachment_feedback_loop_dynamic_state) */
|
||||
#if defined(VK_EXT_buffer_device_address)
|
||||
extern PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT;
|
||||
#endif /* defined(VK_EXT_buffer_device_address) */
|
||||
@@ -1243,9 +1145,6 @@ extern PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT;
|
||||
extern PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT;
|
||||
extern PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT;
|
||||
#endif /* defined(VK_EXT_debug_utils) */
|
||||
#if defined(VK_EXT_depth_bias_control)
|
||||
extern PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT;
|
||||
#endif /* defined(VK_EXT_depth_bias_control) */
|
||||
#if defined(VK_EXT_descriptor_buffer)
|
||||
extern PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT;
|
||||
extern PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT;
|
||||
@@ -1258,9 +1157,9 @@ extern PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescr
|
||||
extern PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT;
|
||||
extern PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT;
|
||||
#endif /* defined(VK_EXT_descriptor_buffer) */
|
||||
#if defined(VK_EXT_descriptor_buffer) && (defined(VK_KHR_acceleration_structure) || defined(VK_NV_ray_tracing))
|
||||
#if defined(VK_EXT_descriptor_buffer) && defined(VK_KHR_acceleration_structure) && defined(VK_NV_ray_tracing)
|
||||
extern PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT;
|
||||
#endif /* defined(VK_EXT_descriptor_buffer) && (defined(VK_KHR_acceleration_structure) || defined(VK_NV_ray_tracing)) */
|
||||
#endif /* defined(VK_EXT_descriptor_buffer) && defined(VK_KHR_acceleration_structure) && defined(VK_NV_ray_tracing) */
|
||||
#if defined(VK_EXT_device_fault)
|
||||
extern PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT;
|
||||
#endif /* defined(VK_EXT_device_fault) */
|
||||
@@ -1274,10 +1173,6 @@ extern PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDevice
|
||||
#if defined(VK_EXT_discard_rectangles)
|
||||
extern PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT;
|
||||
#endif /* defined(VK_EXT_discard_rectangles) */
|
||||
#if defined(VK_EXT_discard_rectangles) && VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION >= 2
|
||||
extern PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT;
|
||||
extern PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT;
|
||||
#endif /* defined(VK_EXT_discard_rectangles) && VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION >= 2 */
|
||||
#if defined(VK_EXT_display_control)
|
||||
extern PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT;
|
||||
extern PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT;
|
||||
@@ -1287,6 +1182,60 @@ extern PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT;
|
||||
#if defined(VK_EXT_display_surface_counter)
|
||||
extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT;
|
||||
#endif /* defined(VK_EXT_display_surface_counter) */
|
||||
#if defined(VK_EXT_extended_dynamic_state)
|
||||
extern PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT;
|
||||
extern PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT;
|
||||
extern PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT;
|
||||
extern PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT;
|
||||
extern PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT;
|
||||
extern PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT;
|
||||
extern PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT;
|
||||
extern PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT;
|
||||
extern PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT;
|
||||
extern PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT;
|
||||
extern PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT;
|
||||
extern PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT;
|
||||
#endif /* defined(VK_EXT_extended_dynamic_state) */
|
||||
#if defined(VK_EXT_extended_dynamic_state2)
|
||||
extern PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT;
|
||||
extern PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT;
|
||||
extern PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT;
|
||||
extern PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT;
|
||||
extern PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT;
|
||||
#endif /* defined(VK_EXT_extended_dynamic_state2) */
|
||||
#if defined(VK_EXT_extended_dynamic_state3)
|
||||
extern PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
|
||||
extern PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
|
||||
extern PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
extern PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
|
||||
extern PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
|
||||
extern PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
|
||||
extern PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
extern PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV;
|
||||
extern PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV;
|
||||
extern PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV;
|
||||
extern PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV;
|
||||
extern PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV;
|
||||
extern PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV;
|
||||
extern PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
|
||||
extern PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
extern PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
extern PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
extern PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
extern PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
extern PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
|
||||
extern PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
|
||||
extern PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
extern PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
|
||||
extern PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
extern PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV;
|
||||
extern PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
extern PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
|
||||
extern PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV;
|
||||
extern PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
extern PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV;
|
||||
extern PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
|
||||
#endif /* defined(VK_EXT_extended_dynamic_state3) */
|
||||
#if defined(VK_EXT_external_memory_host)
|
||||
extern PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT;
|
||||
#endif /* defined(VK_EXT_external_memory_host) */
|
||||
@@ -1301,15 +1250,12 @@ extern PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT;
|
||||
#if defined(VK_EXT_headless_surface)
|
||||
extern PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT;
|
||||
#endif /* defined(VK_EXT_headless_surface) */
|
||||
#if defined(VK_EXT_host_image_copy)
|
||||
extern PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT;
|
||||
extern PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT;
|
||||
extern PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT;
|
||||
extern PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT;
|
||||
#endif /* defined(VK_EXT_host_image_copy) */
|
||||
#if defined(VK_EXT_host_query_reset)
|
||||
extern PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT;
|
||||
#endif /* defined(VK_EXT_host_query_reset) */
|
||||
#if defined(VK_EXT_image_compression_control)
|
||||
extern PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT;
|
||||
#endif /* defined(VK_EXT_image_compression_control) */
|
||||
#if defined(VK_EXT_image_drm_format_modifier)
|
||||
extern PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT;
|
||||
#endif /* defined(VK_EXT_image_drm_format_modifier) */
|
||||
@@ -1367,12 +1313,6 @@ extern PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultis
|
||||
extern PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT;
|
||||
extern PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT;
|
||||
#endif /* defined(VK_EXT_shader_module_identifier) */
|
||||
#if defined(VK_EXT_shader_object)
|
||||
extern PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT;
|
||||
extern PFN_vkCreateShadersEXT vkCreateShadersEXT;
|
||||
extern PFN_vkDestroyShaderEXT vkDestroyShaderEXT;
|
||||
extern PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT;
|
||||
#endif /* defined(VK_EXT_shader_object) */
|
||||
#if defined(VK_EXT_swapchain_maintenance1)
|
||||
extern PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT;
|
||||
#endif /* defined(VK_EXT_swapchain_maintenance1) */
|
||||
@@ -1393,6 +1333,9 @@ extern PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT;
|
||||
extern PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT;
|
||||
extern PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT;
|
||||
#endif /* defined(VK_EXT_validation_cache) */
|
||||
#if defined(VK_EXT_vertex_input_dynamic_state)
|
||||
extern PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT;
|
||||
#endif /* defined(VK_EXT_vertex_input_dynamic_state) */
|
||||
#if defined(VK_FUCHSIA_buffer_collection)
|
||||
extern PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA;
|
||||
extern PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA;
|
||||
@@ -1418,10 +1361,6 @@ extern PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP
|
||||
extern PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE;
|
||||
extern PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE;
|
||||
#endif /* defined(VK_GOOGLE_display_timing) */
|
||||
#if defined(VK_HUAWEI_cluster_culling_shader)
|
||||
extern PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI;
|
||||
extern PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI;
|
||||
#endif /* defined(VK_HUAWEI_cluster_culling_shader) */
|
||||
#if defined(VK_HUAWEI_invocation_mask)
|
||||
extern PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI;
|
||||
#endif /* defined(VK_HUAWEI_invocation_mask) */
|
||||
@@ -1470,9 +1409,6 @@ extern PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR;
|
||||
extern PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR;
|
||||
extern PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR;
|
||||
#endif /* defined(VK_KHR_buffer_device_address) */
|
||||
#if defined(VK_KHR_cooperative_matrix)
|
||||
extern PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR;
|
||||
#endif /* defined(VK_KHR_cooperative_matrix) */
|
||||
#if defined(VK_KHR_copy_commands2)
|
||||
extern PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR;
|
||||
extern PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR;
|
||||
@@ -1599,16 +1535,6 @@ extern PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequire
|
||||
extern PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR;
|
||||
extern PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR;
|
||||
#endif /* defined(VK_KHR_maintenance4) */
|
||||
#if defined(VK_KHR_maintenance5)
|
||||
extern PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR;
|
||||
extern PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR;
|
||||
extern PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR;
|
||||
extern PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR;
|
||||
#endif /* defined(VK_KHR_maintenance5) */
|
||||
#if defined(VK_KHR_map_memory2)
|
||||
extern PFN_vkMapMemory2KHR vkMapMemory2KHR;
|
||||
extern PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR;
|
||||
#endif /* defined(VK_KHR_map_memory2) */
|
||||
#if defined(VK_KHR_performance_query)
|
||||
extern PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR;
|
||||
extern PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
|
||||
@@ -1683,8 +1609,6 @@ extern PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR;
|
||||
#endif /* defined(VK_KHR_video_decode_queue) */
|
||||
#if defined(VK_KHR_video_encode_queue)
|
||||
extern PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR;
|
||||
extern PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR;
|
||||
extern PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR;
|
||||
#endif /* defined(VK_KHR_video_encode_queue) */
|
||||
#if defined(VK_KHR_video_queue)
|
||||
extern PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR;
|
||||
@@ -1753,14 +1677,6 @@ extern PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV;
|
||||
#if defined(VK_NV_coverage_reduction_mode)
|
||||
extern PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
|
||||
#endif /* defined(VK_NV_coverage_reduction_mode) */
|
||||
#if defined(VK_NV_cuda_kernel_launch)
|
||||
extern PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV;
|
||||
extern PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV;
|
||||
extern PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV;
|
||||
extern PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV;
|
||||
extern PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV;
|
||||
extern PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV;
|
||||
#endif /* defined(VK_NV_cuda_kernel_launch) */
|
||||
#if defined(VK_NV_device_diagnostic_checkpoints)
|
||||
extern PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV;
|
||||
extern PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV;
|
||||
@@ -1773,11 +1689,6 @@ extern PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV;
|
||||
extern PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV;
|
||||
extern PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV;
|
||||
#endif /* defined(VK_NV_device_generated_commands) */
|
||||
#if defined(VK_NV_device_generated_commands_compute)
|
||||
extern PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV;
|
||||
extern PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV;
|
||||
extern PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV;
|
||||
#endif /* defined(VK_NV_device_generated_commands_compute) */
|
||||
#if defined(VK_NV_external_memory_capabilities)
|
||||
extern PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
|
||||
#endif /* defined(VK_NV_external_memory_capabilities) */
|
||||
@@ -1790,13 +1701,6 @@ extern PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV;
|
||||
#if defined(VK_NV_fragment_shading_rate_enums)
|
||||
extern PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV;
|
||||
#endif /* defined(VK_NV_fragment_shading_rate_enums) */
|
||||
#if defined(VK_NV_low_latency2)
|
||||
extern PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV;
|
||||
extern PFN_vkLatencySleepNV vkLatencySleepNV;
|
||||
extern PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV;
|
||||
extern PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV;
|
||||
extern PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV;
|
||||
#endif /* defined(VK_NV_low_latency2) */
|
||||
#if defined(VK_NV_memory_decompression)
|
||||
extern PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV;
|
||||
extern PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV;
|
||||
@@ -1827,9 +1731,6 @@ extern PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV
|
||||
extern PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV;
|
||||
extern PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV;
|
||||
#endif /* defined(VK_NV_ray_tracing) */
|
||||
#if defined(VK_NV_scissor_exclusive) && VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION >= 2
|
||||
extern PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV;
|
||||
#endif /* defined(VK_NV_scissor_exclusive) && VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION >= 2 */
|
||||
#if defined(VK_NV_scissor_exclusive)
|
||||
extern PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV;
|
||||
#endif /* defined(VK_NV_scissor_exclusive) */
|
||||
@@ -1842,9 +1743,6 @@ extern PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePalet
|
||||
extern PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM;
|
||||
extern PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM;
|
||||
#endif /* defined(VK_QCOM_tile_properties) */
|
||||
#if defined(VK_QNX_external_memory_screen_buffer)
|
||||
extern PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX;
|
||||
#endif /* defined(VK_QNX_external_memory_screen_buffer) */
|
||||
#if defined(VK_QNX_screen_surface)
|
||||
extern PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX;
|
||||
extern PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX;
|
||||
@@ -1853,83 +1751,9 @@ extern PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceSc
|
||||
extern PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE;
|
||||
extern PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE;
|
||||
#endif /* defined(VK_VALVE_descriptor_set_host_mapping) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object))
|
||||
extern PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT;
|
||||
extern PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT;
|
||||
extern PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT;
|
||||
extern PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT;
|
||||
extern PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT;
|
||||
extern PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT;
|
||||
extern PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT;
|
||||
extern PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT;
|
||||
extern PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT;
|
||||
extern PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT;
|
||||
extern PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT;
|
||||
extern PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object))
|
||||
extern PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT;
|
||||
extern PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT;
|
||||
extern PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT;
|
||||
extern PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT;
|
||||
extern PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
|
||||
extern PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
|
||||
extern PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
|
||||
extern PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
|
||||
extern PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
|
||||
extern PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
|
||||
extern PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
|
||||
extern PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
|
||||
extern PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
|
||||
extern PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
|
||||
extern PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
|
||||
extern PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
|
||||
extern PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
|
||||
extern PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
|
||||
extern PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
|
||||
extern PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
|
||||
extern PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
|
||||
extern PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
|
||||
extern PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
|
||||
extern PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
|
||||
extern PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
|
||||
extern PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
|
||||
extern PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_viewport_swizzle)) || (defined(VK_EXT_shader_object) && defined(VK_NV_viewport_swizzle))
|
||||
extern PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_viewport_swizzle)) || (defined(VK_EXT_shader_object) && defined(VK_NV_viewport_swizzle)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_fragment_coverage_to_color)) || (defined(VK_EXT_shader_object) && defined(VK_NV_fragment_coverage_to_color))
|
||||
extern PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV;
|
||||
extern PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_fragment_coverage_to_color)) || (defined(VK_EXT_shader_object) && defined(VK_NV_fragment_coverage_to_color)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_framebuffer_mixed_samples)) || (defined(VK_EXT_shader_object) && defined(VK_NV_framebuffer_mixed_samples))
|
||||
extern PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV;
|
||||
extern PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV;
|
||||
extern PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_framebuffer_mixed_samples)) || (defined(VK_EXT_shader_object) && defined(VK_NV_framebuffer_mixed_samples)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_shading_rate_image)) || (defined(VK_EXT_shader_object) && defined(VK_NV_shading_rate_image))
|
||||
extern PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_shading_rate_image)) || (defined(VK_EXT_shader_object) && defined(VK_NV_shading_rate_image)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_representative_fragment_test)) || (defined(VK_EXT_shader_object) && defined(VK_NV_representative_fragment_test))
|
||||
extern PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_representative_fragment_test)) || (defined(VK_EXT_shader_object) && defined(VK_NV_representative_fragment_test)) */
|
||||
#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_coverage_reduction_mode)) || (defined(VK_EXT_shader_object) && defined(VK_NV_coverage_reduction_mode))
|
||||
extern PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV;
|
||||
#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_coverage_reduction_mode)) || (defined(VK_EXT_shader_object) && defined(VK_NV_coverage_reduction_mode)) */
|
||||
#if (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1))
|
||||
extern PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT;
|
||||
#endif /* (defined(VK_EXT_full_screen_exclusive) && defined(VK_KHR_device_group)) || (defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1)) */
|
||||
#if (defined(VK_EXT_host_image_copy)) || (defined(VK_EXT_image_compression_control))
|
||||
extern PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT;
|
||||
#endif /* (defined(VK_EXT_host_image_copy)) || (defined(VK_EXT_image_compression_control)) */
|
||||
#if (defined(VK_EXT_shader_object)) || (defined(VK_EXT_vertex_input_dynamic_state))
|
||||
extern PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT;
|
||||
#endif /* (defined(VK_EXT_shader_object)) || (defined(VK_EXT_vertex_input_dynamic_state)) */
|
||||
#if (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) || (defined(VK_KHR_push_descriptor) && defined(VK_KHR_descriptor_update_template))
|
||||
extern PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR;
|
||||
#endif /* (defined(VK_KHR_descriptor_update_template) && defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1)) || (defined(VK_KHR_push_descriptor) && defined(VK_KHR_descriptor_update_template)) */
|
||||
@@ -1958,7 +1782,7 @@ extern PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Copyright (c) 2018-2023 Arseny Kapoulkine
|
||||
* Copyright (c) 2018-2022 Arseny Kapoulkine
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
|
||||
-392
@@ -1,392 +0,0 @@
|
||||
#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_
|
||||
#define VULKAN_VIDEO_CODEC_AV1STD_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos Vulkan XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_av1std 1
|
||||
#include "vulkan_video_codecs_common.h"
|
||||
#define STD_VIDEO_AV1_NUM_REF_FRAMES 8
|
||||
#define STD_VIDEO_AV1_REFS_PER_FRAME 7
|
||||
#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8
|
||||
#define STD_VIDEO_AV1_MAX_TILE_COLS 64
|
||||
#define STD_VIDEO_AV1_MAX_TILE_ROWS 64
|
||||
#define STD_VIDEO_AV1_MAX_SEGMENTS 8
|
||||
#define STD_VIDEO_AV1_SEG_LVL_MAX 8
|
||||
#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7
|
||||
#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2
|
||||
#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2
|
||||
#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2
|
||||
#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4
|
||||
#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2
|
||||
#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8
|
||||
#define STD_VIDEO_AV1_MAX_NUM_PLANES 3
|
||||
#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6
|
||||
#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14
|
||||
#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10
|
||||
#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10
|
||||
#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24
|
||||
#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25
|
||||
|
||||
typedef enum StdVideoAV1Profile {
|
||||
STD_VIDEO_AV1_PROFILE_MAIN = 0,
|
||||
STD_VIDEO_AV1_PROFILE_HIGH = 1,
|
||||
STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2,
|
||||
STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1Profile;
|
||||
|
||||
typedef enum StdVideoAV1Level {
|
||||
STD_VIDEO_AV1_LEVEL_2_0 = 0,
|
||||
STD_VIDEO_AV1_LEVEL_2_1 = 1,
|
||||
STD_VIDEO_AV1_LEVEL_2_2 = 2,
|
||||
STD_VIDEO_AV1_LEVEL_2_3 = 3,
|
||||
STD_VIDEO_AV1_LEVEL_3_0 = 4,
|
||||
STD_VIDEO_AV1_LEVEL_3_1 = 5,
|
||||
STD_VIDEO_AV1_LEVEL_3_2 = 6,
|
||||
STD_VIDEO_AV1_LEVEL_3_3 = 7,
|
||||
STD_VIDEO_AV1_LEVEL_4_0 = 8,
|
||||
STD_VIDEO_AV1_LEVEL_4_1 = 9,
|
||||
STD_VIDEO_AV1_LEVEL_4_2 = 10,
|
||||
STD_VIDEO_AV1_LEVEL_4_3 = 11,
|
||||
STD_VIDEO_AV1_LEVEL_5_0 = 12,
|
||||
STD_VIDEO_AV1_LEVEL_5_1 = 13,
|
||||
STD_VIDEO_AV1_LEVEL_5_2 = 14,
|
||||
STD_VIDEO_AV1_LEVEL_5_3 = 15,
|
||||
STD_VIDEO_AV1_LEVEL_6_0 = 16,
|
||||
STD_VIDEO_AV1_LEVEL_6_1 = 17,
|
||||
STD_VIDEO_AV1_LEVEL_6_2 = 18,
|
||||
STD_VIDEO_AV1_LEVEL_6_3 = 19,
|
||||
STD_VIDEO_AV1_LEVEL_7_0 = 20,
|
||||
STD_VIDEO_AV1_LEVEL_7_1 = 21,
|
||||
STD_VIDEO_AV1_LEVEL_7_2 = 22,
|
||||
STD_VIDEO_AV1_LEVEL_7_3 = 23,
|
||||
STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1Level;
|
||||
|
||||
typedef enum StdVideoAV1FrameType {
|
||||
STD_VIDEO_AV1_FRAME_TYPE_KEY = 0,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_INTER = 1,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1FrameType;
|
||||
|
||||
typedef enum StdVideoAV1ReferenceName {
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1ReferenceName;
|
||||
|
||||
typedef enum StdVideoAV1InterpolationFilter {
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1InterpolationFilter;
|
||||
|
||||
typedef enum StdVideoAV1TxMode {
|
||||
STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0,
|
||||
STD_VIDEO_AV1_TX_MODE_LARGEST = 1,
|
||||
STD_VIDEO_AV1_TX_MODE_SELECT = 2,
|
||||
STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1TxMode;
|
||||
|
||||
typedef enum StdVideoAV1FrameRestorationType {
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1FrameRestorationType;
|
||||
|
||||
typedef enum StdVideoAV1ColorPrimaries {
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = 2,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1ColorPrimaries;
|
||||
|
||||
typedef enum StdVideoAV1TransferCharacteristics {
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1TransferCharacteristics;
|
||||
|
||||
typedef enum StdVideoAV1MatrixCoefficients {
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1MatrixCoefficients;
|
||||
|
||||
typedef enum StdVideoAV1ChromaSamplePosition {
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF,
|
||||
STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF
|
||||
} StdVideoAV1ChromaSamplePosition;
|
||||
typedef struct StdVideoAV1ColorConfigFlags {
|
||||
uint32_t mono_chrome : 1;
|
||||
uint32_t color_range : 1;
|
||||
uint32_t separate_uv_delta_q : 1;
|
||||
uint32_t color_description_present_flag : 1;
|
||||
uint32_t reserved : 28;
|
||||
} StdVideoAV1ColorConfigFlags;
|
||||
|
||||
typedef struct StdVideoAV1ColorConfig {
|
||||
StdVideoAV1ColorConfigFlags flags;
|
||||
uint8_t BitDepth;
|
||||
uint8_t subsampling_x;
|
||||
uint8_t subsampling_y;
|
||||
uint8_t reserved1;
|
||||
StdVideoAV1ColorPrimaries color_primaries;
|
||||
StdVideoAV1TransferCharacteristics transfer_characteristics;
|
||||
StdVideoAV1MatrixCoefficients matrix_coefficients;
|
||||
StdVideoAV1ChromaSamplePosition chroma_sample_position;
|
||||
} StdVideoAV1ColorConfig;
|
||||
|
||||
typedef struct StdVideoAV1TimingInfoFlags {
|
||||
uint32_t equal_picture_interval : 1;
|
||||
uint32_t reserved : 31;
|
||||
} StdVideoAV1TimingInfoFlags;
|
||||
|
||||
typedef struct StdVideoAV1TimingInfo {
|
||||
StdVideoAV1TimingInfoFlags flags;
|
||||
uint32_t num_units_in_display_tick;
|
||||
uint32_t time_scale;
|
||||
uint32_t num_ticks_per_picture_minus_1;
|
||||
} StdVideoAV1TimingInfo;
|
||||
|
||||
typedef struct StdVideoAV1LoopFilterFlags {
|
||||
uint32_t loop_filter_delta_enabled : 1;
|
||||
uint32_t loop_filter_delta_update : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoAV1LoopFilterFlags;
|
||||
|
||||
typedef struct StdVideoAV1LoopFilter {
|
||||
StdVideoAV1LoopFilterFlags flags;
|
||||
uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS];
|
||||
uint8_t loop_filter_sharpness;
|
||||
uint8_t update_ref_delta;
|
||||
int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME];
|
||||
uint8_t update_mode_delta;
|
||||
int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS];
|
||||
} StdVideoAV1LoopFilter;
|
||||
|
||||
typedef struct StdVideoAV1QuantizationFlags {
|
||||
uint32_t using_qmatrix : 1;
|
||||
uint32_t diff_uv_delta : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoAV1QuantizationFlags;
|
||||
|
||||
typedef struct StdVideoAV1Quantization {
|
||||
StdVideoAV1QuantizationFlags flags;
|
||||
uint8_t base_q_idx;
|
||||
int8_t DeltaQYDc;
|
||||
int8_t DeltaQUDc;
|
||||
int8_t DeltaQUAc;
|
||||
int8_t DeltaQVDc;
|
||||
int8_t DeltaQVAc;
|
||||
uint8_t qm_y;
|
||||
uint8_t qm_u;
|
||||
uint8_t qm_v;
|
||||
} StdVideoAV1Quantization;
|
||||
|
||||
typedef struct StdVideoAV1Segmentation {
|
||||
uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS];
|
||||
int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX];
|
||||
} StdVideoAV1Segmentation;
|
||||
|
||||
typedef struct StdVideoAV1TileInfoFlags {
|
||||
uint32_t uniform_tile_spacing_flag : 1;
|
||||
uint32_t reserved : 31;
|
||||
} StdVideoAV1TileInfoFlags;
|
||||
|
||||
typedef struct StdVideoAV1TileInfo {
|
||||
StdVideoAV1TileInfoFlags flags;
|
||||
uint8_t TileCols;
|
||||
uint8_t TileRows;
|
||||
uint16_t context_update_tile_id;
|
||||
uint8_t tile_size_bytes_minus_1;
|
||||
uint8_t reserved1[7];
|
||||
const uint16_t* pMiColStarts;
|
||||
const uint16_t* pMiRowStarts;
|
||||
const uint16_t* pWidthInSbsMinus1;
|
||||
const uint16_t* pHeightInSbsMinus1;
|
||||
} StdVideoAV1TileInfo;
|
||||
|
||||
typedef struct StdVideoAV1CDEF {
|
||||
uint8_t cdef_damping_minus_3;
|
||||
uint8_t cdef_bits;
|
||||
uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
|
||||
uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
|
||||
uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
|
||||
uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
|
||||
} StdVideoAV1CDEF;
|
||||
|
||||
typedef struct StdVideoAV1LoopRestoration {
|
||||
StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES];
|
||||
uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES];
|
||||
} StdVideoAV1LoopRestoration;
|
||||
|
||||
typedef struct StdVideoAV1GlobalMotion {
|
||||
uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES];
|
||||
int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS];
|
||||
} StdVideoAV1GlobalMotion;
|
||||
|
||||
typedef struct StdVideoAV1FilmGrainFlags {
|
||||
uint32_t chroma_scaling_from_luma : 1;
|
||||
uint32_t overlap_flag : 1;
|
||||
uint32_t clip_to_restricted_range : 1;
|
||||
uint32_t update_grain : 1;
|
||||
uint32_t reserved : 28;
|
||||
} StdVideoAV1FilmGrainFlags;
|
||||
|
||||
typedef struct StdVideoAV1FilmGrain {
|
||||
StdVideoAV1FilmGrainFlags flags;
|
||||
uint8_t grain_scaling_minus_8;
|
||||
uint8_t ar_coeff_lag;
|
||||
uint8_t ar_coeff_shift_minus_6;
|
||||
uint8_t grain_scale_shift;
|
||||
uint16_t grain_seed;
|
||||
uint8_t film_grain_params_ref_idx;
|
||||
uint8_t num_y_points;
|
||||
uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS];
|
||||
uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS];
|
||||
uint8_t num_cb_points;
|
||||
uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS];
|
||||
uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS];
|
||||
uint8_t num_cr_points;
|
||||
uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS];
|
||||
uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS];
|
||||
int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA];
|
||||
int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA];
|
||||
int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA];
|
||||
uint8_t cb_mult;
|
||||
uint8_t cb_luma_mult;
|
||||
uint16_t cb_offset;
|
||||
uint8_t cr_mult;
|
||||
uint8_t cr_luma_mult;
|
||||
uint16_t cr_offset;
|
||||
} StdVideoAV1FilmGrain;
|
||||
|
||||
typedef struct StdVideoAV1SequenceHeaderFlags {
|
||||
uint32_t still_picture : 1;
|
||||
uint32_t reduced_still_picture_header : 1;
|
||||
uint32_t use_128x128_superblock : 1;
|
||||
uint32_t enable_filter_intra : 1;
|
||||
uint32_t enable_intra_edge_filter : 1;
|
||||
uint32_t enable_interintra_compound : 1;
|
||||
uint32_t enable_masked_compound : 1;
|
||||
uint32_t enable_warped_motion : 1;
|
||||
uint32_t enable_dual_filter : 1;
|
||||
uint32_t enable_order_hint : 1;
|
||||
uint32_t enable_jnt_comp : 1;
|
||||
uint32_t enable_ref_frame_mvs : 1;
|
||||
uint32_t frame_id_numbers_present_flag : 1;
|
||||
uint32_t enable_superres : 1;
|
||||
uint32_t enable_cdef : 1;
|
||||
uint32_t enable_restoration : 1;
|
||||
uint32_t film_grain_params_present : 1;
|
||||
uint32_t timing_info_present_flag : 1;
|
||||
uint32_t initial_display_delay_present_flag : 1;
|
||||
uint32_t reserved : 13;
|
||||
} StdVideoAV1SequenceHeaderFlags;
|
||||
|
||||
typedef struct StdVideoAV1SequenceHeader {
|
||||
StdVideoAV1SequenceHeaderFlags flags;
|
||||
StdVideoAV1Profile seq_profile;
|
||||
uint8_t frame_width_bits_minus_1;
|
||||
uint8_t frame_height_bits_minus_1;
|
||||
uint16_t max_frame_width_minus_1;
|
||||
uint16_t max_frame_height_minus_1;
|
||||
uint8_t delta_frame_id_length_minus_2;
|
||||
uint8_t additional_frame_id_length_minus_1;
|
||||
uint8_t order_hint_bits_minus_1;
|
||||
uint8_t seq_force_integer_mv;
|
||||
uint8_t seq_force_screen_content_tools;
|
||||
uint8_t reserved1[5];
|
||||
const StdVideoAV1ColorConfig* pColorConfig;
|
||||
const StdVideoAV1TimingInfo* pTimingInfo;
|
||||
} StdVideoAV1SequenceHeader;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
-109
@@ -1,109 +0,0 @@
|
||||
#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_
|
||||
#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/*
|
||||
** This header is generated from the Khronos Vulkan XML API Registry.
|
||||
**
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_av1std_decode is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_av1std_decode 1
|
||||
#include "vulkan_video_codec_av1std.h"
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode"
|
||||
typedef struct StdVideoDecodeAV1PictureInfoFlags {
|
||||
uint32_t error_resilient_mode : 1;
|
||||
uint32_t disable_cdf_update : 1;
|
||||
uint32_t use_superres : 1;
|
||||
uint32_t render_and_frame_size_different : 1;
|
||||
uint32_t allow_screen_content_tools : 1;
|
||||
uint32_t is_filter_switchable : 1;
|
||||
uint32_t force_integer_mv : 1;
|
||||
uint32_t frame_size_override_flag : 1;
|
||||
uint32_t buffer_removal_time_present_flag : 1;
|
||||
uint32_t allow_intrabc : 1;
|
||||
uint32_t frame_refs_short_signaling : 1;
|
||||
uint32_t allow_high_precision_mv : 1;
|
||||
uint32_t is_motion_mode_switchable : 1;
|
||||
uint32_t use_ref_frame_mvs : 1;
|
||||
uint32_t disable_frame_end_update_cdf : 1;
|
||||
uint32_t allow_warped_motion : 1;
|
||||
uint32_t reduced_tx_set : 1;
|
||||
uint32_t reference_select : 1;
|
||||
uint32_t skip_mode_present : 1;
|
||||
uint32_t delta_q_present : 1;
|
||||
uint32_t delta_lf_present : 1;
|
||||
uint32_t delta_lf_multi : 1;
|
||||
uint32_t segmentation_enabled : 1;
|
||||
uint32_t segmentation_update_map : 1;
|
||||
uint32_t segmentation_temporal_update : 1;
|
||||
uint32_t segmentation_update_data : 1;
|
||||
uint32_t UsesLr : 1;
|
||||
uint32_t usesChromaLr : 1;
|
||||
uint32_t apply_grain : 1;
|
||||
uint32_t reserved : 3;
|
||||
} StdVideoDecodeAV1PictureInfoFlags;
|
||||
|
||||
typedef struct StdVideoDecodeAV1PictureInfo {
|
||||
StdVideoDecodeAV1PictureInfoFlags flags;
|
||||
StdVideoAV1FrameType frame_type;
|
||||
uint32_t current_frame_id;
|
||||
uint8_t OrderHint;
|
||||
uint8_t primary_ref_frame;
|
||||
uint8_t refresh_frame_flags;
|
||||
uint8_t reserved1;
|
||||
StdVideoAV1InterpolationFilter interpolation_filter;
|
||||
StdVideoAV1TxMode TxMode;
|
||||
uint8_t delta_q_res;
|
||||
uint8_t delta_lf_res;
|
||||
uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES];
|
||||
uint8_t coded_denom;
|
||||
uint8_t reserved2[3];
|
||||
uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
|
||||
uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES];
|
||||
const StdVideoAV1TileInfo* pTileInfo;
|
||||
const StdVideoAV1Quantization* pQuantization;
|
||||
const StdVideoAV1Segmentation* pSegmentation;
|
||||
const StdVideoAV1LoopFilter* pLoopFilter;
|
||||
const StdVideoAV1CDEF* pCDEF;
|
||||
const StdVideoAV1LoopRestoration* pLoopRestoration;
|
||||
const StdVideoAV1GlobalMotion* pGlobalMotion;
|
||||
const StdVideoAV1FilmGrain* pFilmGrain;
|
||||
} StdVideoDecodeAV1PictureInfo;
|
||||
|
||||
typedef struct StdVideoDecodeAV1ReferenceInfoFlags {
|
||||
uint32_t disable_frame_end_update_cdf : 1;
|
||||
uint32_t segmentation_enabled : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoDecodeAV1ReferenceInfoFlags;
|
||||
|
||||
typedef struct StdVideoDecodeAV1ReferenceInfo {
|
||||
StdVideoDecodeAV1ReferenceInfoFlags flags;
|
||||
uint8_t frame_type;
|
||||
uint8_t RefFrameSignBias;
|
||||
uint8_t OrderHint;
|
||||
uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
|
||||
} StdVideoDecodeAV1ReferenceInfo;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
+2
-4
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VIDEO_CODEC_H264STD_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,9 +19,8 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_h264std 1
|
||||
#include "vulkan_video_codecs_common.h"
|
||||
#include <stdint.h>
|
||||
#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32
|
||||
#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6
|
||||
#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16
|
||||
@@ -29,7 +28,6 @@ extern "C" {
|
||||
#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64
|
||||
#define STD_VIDEO_H264_MAX_NUM_LIST_REF 32
|
||||
#define STD_VIDEO_H264_MAX_CHROMA_PLANES 2
|
||||
#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFF
|
||||
|
||||
typedef enum StdVideoH264ChromaFormatIdc {
|
||||
STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0,
|
||||
|
||||
+2
-4
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,15 +19,13 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_h264std_decode is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_h264std_decode 1
|
||||
#include "vulkan_video_codec_h264std.h"
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
|
||||
|
||||
#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode"
|
||||
#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2
|
||||
|
||||
typedef enum StdVideoDecodeH264FieldOrderCount {
|
||||
STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0,
|
||||
|
||||
+30
-36
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,13 +19,11 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_h264std_encode is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_h264std_encode 1
|
||||
#include "vulkan_video_codec_h264std.h"
|
||||
// Vulkan 0.9 provisional Vulkan video H.264 encode std specification version number
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_9 VK_MAKE_VIDEO_STD_VERSION(0, 9, 9)
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_9
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode"
|
||||
typedef struct StdVideoEncodeH264WeightTableFlags {
|
||||
uint32_t luma_weight_l0_flag;
|
||||
@@ -51,27 +49,24 @@ typedef struct StdVideoEncodeH264WeightTable {
|
||||
typedef struct StdVideoEncodeH264SliceHeaderFlags {
|
||||
uint32_t direct_spatial_mv_pred_flag : 1;
|
||||
uint32_t num_ref_idx_active_override_flag : 1;
|
||||
uint32_t reserved : 30;
|
||||
uint32_t no_output_of_prior_pics_flag : 1;
|
||||
uint32_t adaptive_ref_pic_marking_mode_flag : 1;
|
||||
uint32_t no_prior_references_available_flag : 1;
|
||||
} StdVideoEncodeH264SliceHeaderFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH264PictureInfoFlags {
|
||||
uint32_t IdrPicFlag : 1;
|
||||
uint32_t is_reference : 1;
|
||||
uint32_t no_output_of_prior_pics_flag : 1;
|
||||
uint32_t long_term_reference_flag : 1;
|
||||
uint32_t adaptive_ref_pic_marking_mode_flag : 1;
|
||||
uint32_t reserved : 27;
|
||||
uint32_t idr_flag : 1;
|
||||
uint32_t is_reference_flag : 1;
|
||||
uint32_t used_for_long_term_reference : 1;
|
||||
} StdVideoEncodeH264PictureInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH264ReferenceInfoFlags {
|
||||
uint32_t used_for_long_term_reference : 1;
|
||||
uint32_t reserved : 31;
|
||||
} StdVideoEncodeH264ReferenceInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH264ReferenceListsInfoFlags {
|
||||
uint32_t ref_pic_list_modification_flag_l0 : 1;
|
||||
uint32_t ref_pic_list_modification_flag_l1 : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoEncodeH264ReferenceListsInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH264RefListModEntry {
|
||||
@@ -81,7 +76,7 @@ typedef struct StdVideoEncodeH264RefListModEntry {
|
||||
} StdVideoEncodeH264RefListModEntry;
|
||||
|
||||
typedef struct StdVideoEncodeH264RefPicMarkingEntry {
|
||||
StdVideoH264MemMgmtControlOp memory_management_control_operation;
|
||||
StdVideoH264MemMgmtControlOp operation;
|
||||
uint16_t difference_of_pic_nums_minus1;
|
||||
uint16_t long_term_pic_num;
|
||||
uint16_t long_term_frame_idx;
|
||||
@@ -90,52 +85,51 @@ typedef struct StdVideoEncodeH264RefPicMarkingEntry {
|
||||
|
||||
typedef struct StdVideoEncodeH264ReferenceListsInfo {
|
||||
StdVideoEncodeH264ReferenceListsInfoFlags flags;
|
||||
uint8_t num_ref_idx_l0_active_minus1;
|
||||
uint8_t num_ref_idx_l1_active_minus1;
|
||||
uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF];
|
||||
uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF];
|
||||
uint8_t refPicList0EntryCount;
|
||||
uint8_t refPicList1EntryCount;
|
||||
uint8_t refList0ModOpCount;
|
||||
uint8_t refList1ModOpCount;
|
||||
uint8_t refPicMarkingOpCount;
|
||||
uint8_t reserved1[7];
|
||||
const uint8_t* pRefPicList0Entries;
|
||||
const uint8_t* pRefPicList1Entries;
|
||||
const StdVideoEncodeH264RefListModEntry* pRefList0ModOperations;
|
||||
const StdVideoEncodeH264RefListModEntry* pRefList1ModOperations;
|
||||
const StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations;
|
||||
} StdVideoEncodeH264ReferenceListsInfo;
|
||||
|
||||
typedef struct StdVideoEncodeH264PictureInfo {
|
||||
StdVideoEncodeH264PictureInfoFlags flags;
|
||||
uint8_t seq_parameter_set_id;
|
||||
uint8_t pic_parameter_set_id;
|
||||
uint16_t idr_pic_id;
|
||||
StdVideoH264PictureType primary_pic_type;
|
||||
uint32_t frame_num;
|
||||
int32_t PicOrderCnt;
|
||||
uint8_t temporal_id;
|
||||
uint8_t reserved1[3];
|
||||
const StdVideoEncodeH264ReferenceListsInfo* pRefLists;
|
||||
StdVideoEncodeH264PictureInfoFlags flags;
|
||||
uint8_t seq_parameter_set_id;
|
||||
uint8_t pic_parameter_set_id;
|
||||
uint16_t reserved1;
|
||||
StdVideoH264PictureType pictureType;
|
||||
uint32_t frame_num;
|
||||
int32_t PicOrderCnt;
|
||||
} StdVideoEncodeH264PictureInfo;
|
||||
|
||||
typedef struct StdVideoEncodeH264ReferenceInfo {
|
||||
StdVideoEncodeH264ReferenceInfoFlags flags;
|
||||
StdVideoH264PictureType primary_pic_type;
|
||||
StdVideoH264PictureType pictureType;
|
||||
uint32_t FrameNum;
|
||||
int32_t PicOrderCnt;
|
||||
uint16_t long_term_pic_num;
|
||||
uint16_t long_term_frame_idx;
|
||||
uint8_t temporal_id;
|
||||
} StdVideoEncodeH264ReferenceInfo;
|
||||
|
||||
typedef struct StdVideoEncodeH264SliceHeader {
|
||||
StdVideoEncodeH264SliceHeaderFlags flags;
|
||||
uint32_t first_mb_in_slice;
|
||||
StdVideoH264SliceType slice_type;
|
||||
int8_t slice_alpha_c0_offset_div2;
|
||||
int8_t slice_beta_offset_div2;
|
||||
int8_t slice_qp_delta;
|
||||
uint8_t reserved1;
|
||||
uint16_t idr_pic_id;
|
||||
uint8_t num_ref_idx_l0_active_minus1;
|
||||
uint8_t num_ref_idx_l1_active_minus1;
|
||||
StdVideoH264CabacInitIdc cabac_init_idc;
|
||||
StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc;
|
||||
int8_t slice_alpha_c0_offset_div2;
|
||||
int8_t slice_beta_offset_div2;
|
||||
uint16_t reserved1;
|
||||
uint32_t reserved2;
|
||||
const StdVideoEncodeH264WeightTable* pWeightTable;
|
||||
} StdVideoEncodeH264SliceHeader;
|
||||
|
||||
|
||||
+6
-9
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VIDEO_CODEC_H265STD_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,11 +19,9 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_h265std 1
|
||||
#include "vulkan_video_codecs_common.h"
|
||||
#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32
|
||||
#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7
|
||||
#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32
|
||||
#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6
|
||||
#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16
|
||||
#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6
|
||||
@@ -32,19 +30,18 @@ extern "C" {
|
||||
#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64
|
||||
#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2
|
||||
#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64
|
||||
#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3
|
||||
#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128
|
||||
#define STD_VIDEO_H265_MAX_DPB_SIZE 16
|
||||
#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32
|
||||
#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6
|
||||
#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19
|
||||
#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21
|
||||
#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3
|
||||
#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128
|
||||
#define STD_VIDEO_H265_MAX_NUM_LIST_REF 15
|
||||
#define STD_VIDEO_H265_MAX_CHROMA_PLANES 2
|
||||
#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64
|
||||
#define STD_VIDEO_H265_MAX_DPB_SIZE 16
|
||||
#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32
|
||||
#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16
|
||||
#define STD_VIDEO_H265_MAX_DELTA_POC 48
|
||||
#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFF
|
||||
|
||||
typedef enum StdVideoH265ChromaFormatIdc {
|
||||
STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0,
|
||||
|
||||
+2
-4
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,15 +19,13 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_h265std_decode is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_h265std_decode 1
|
||||
#include "vulkan_video_codec_h265std.h"
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
|
||||
|
||||
#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode"
|
||||
#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8
|
||||
typedef struct StdVideoDecodeH265PictureInfoFlags {
|
||||
uint32_t IrapPicFlag : 1;
|
||||
uint32_t IdrPicFlag : 1;
|
||||
|
||||
+63
-70
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,13 +19,11 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codec_h265std_encode is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codec_h265std_encode 1
|
||||
#include "vulkan_video_codec_h265std.h"
|
||||
// Vulkan 0.9 provisional Vulkan video H.265 encode std specification version number
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_10 VK_MAKE_VIDEO_STD_VERSION(0, 9, 10)
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
|
||||
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_10
|
||||
#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode"
|
||||
typedef struct StdVideoEncodeH265WeightTableFlags {
|
||||
uint16_t luma_weight_l0_flag;
|
||||
@@ -50,7 +48,11 @@ typedef struct StdVideoEncodeH265WeightTable {
|
||||
|
||||
typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags {
|
||||
uint32_t first_slice_segment_in_pic_flag : 1;
|
||||
uint32_t no_output_of_prior_pics_flag : 1;
|
||||
uint32_t dependent_slice_segment_flag : 1;
|
||||
uint32_t pic_output_flag : 1;
|
||||
uint32_t short_term_ref_pic_set_sps_flag : 1;
|
||||
uint32_t slice_temporal_mvp_enable_flag : 1;
|
||||
uint32_t slice_sao_luma_flag : 1;
|
||||
uint32_t slice_sao_chroma_flag : 1;
|
||||
uint32_t num_ref_idx_active_override_flag : 1;
|
||||
@@ -61,57 +63,9 @@ typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags {
|
||||
uint32_t slice_deblocking_filter_disabled_flag : 1;
|
||||
uint32_t collocated_from_l0_flag : 1;
|
||||
uint32_t slice_loop_filter_across_slices_enabled_flag : 1;
|
||||
uint32_t reserved : 20;
|
||||
} StdVideoEncodeH265SliceSegmentHeaderFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH265SliceSegmentHeader {
|
||||
StdVideoEncodeH265SliceSegmentHeaderFlags flags;
|
||||
StdVideoH265SliceType slice_type;
|
||||
uint32_t slice_segment_address;
|
||||
uint8_t collocated_ref_idx;
|
||||
uint8_t MaxNumMergeCand;
|
||||
int8_t slice_cb_qp_offset;
|
||||
int8_t slice_cr_qp_offset;
|
||||
int8_t slice_beta_offset_div2;
|
||||
int8_t slice_tc_offset_div2;
|
||||
int8_t slice_act_y_qp_offset;
|
||||
int8_t slice_act_cb_qp_offset;
|
||||
int8_t slice_act_cr_qp_offset;
|
||||
int8_t slice_qp_delta;
|
||||
uint16_t reserved1;
|
||||
const StdVideoEncodeH265WeightTable* pWeightTable;
|
||||
} StdVideoEncodeH265SliceSegmentHeader;
|
||||
|
||||
typedef struct StdVideoEncodeH265ReferenceListsInfoFlags {
|
||||
uint32_t ref_pic_list_modification_flag_l0 : 1;
|
||||
uint32_t ref_pic_list_modification_flag_l1 : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoEncodeH265ReferenceListsInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH265ReferenceListsInfo {
|
||||
StdVideoEncodeH265ReferenceListsInfoFlags flags;
|
||||
uint8_t num_ref_idx_l0_active_minus1;
|
||||
uint8_t num_ref_idx_l1_active_minus1;
|
||||
uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF];
|
||||
uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF];
|
||||
uint8_t list_entry_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF];
|
||||
uint8_t list_entry_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF];
|
||||
} StdVideoEncodeH265ReferenceListsInfo;
|
||||
|
||||
typedef struct StdVideoEncodeH265PictureInfoFlags {
|
||||
uint32_t is_reference : 1;
|
||||
uint32_t IrapPicFlag : 1;
|
||||
uint32_t used_for_long_term_reference : 1;
|
||||
uint32_t discardable_flag : 1;
|
||||
uint32_t cross_layer_bla_flag : 1;
|
||||
uint32_t pic_output_flag : 1;
|
||||
uint32_t no_output_of_prior_pics_flag : 1;
|
||||
uint32_t short_term_ref_pic_set_sps_flag : 1;
|
||||
uint32_t slice_temporal_mvp_enabled_flag : 1;
|
||||
uint32_t reserved : 23;
|
||||
} StdVideoEncodeH265PictureInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH265LongTermRefPics {
|
||||
typedef struct StdVideoEncodeH265SliceSegmentLongTermRefPics {
|
||||
uint8_t num_long_term_sps;
|
||||
uint8_t num_long_term_pics;
|
||||
uint8_t lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS];
|
||||
@@ -119,32 +73,71 @@ typedef struct StdVideoEncodeH265LongTermRefPics {
|
||||
uint16_t used_by_curr_pic_lt_flag;
|
||||
uint8_t delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC];
|
||||
uint8_t delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC];
|
||||
} StdVideoEncodeH265LongTermRefPics;
|
||||
} StdVideoEncodeH265SliceSegmentLongTermRefPics;
|
||||
|
||||
typedef struct StdVideoEncodeH265SliceSegmentHeader {
|
||||
StdVideoEncodeH265SliceSegmentHeaderFlags flags;
|
||||
StdVideoH265SliceType slice_type;
|
||||
uint32_t slice_segment_address;
|
||||
uint8_t short_term_ref_pic_set_idx;
|
||||
uint8_t collocated_ref_idx;
|
||||
uint8_t num_ref_idx_l0_active_minus1;
|
||||
uint8_t num_ref_idx_l1_active_minus1;
|
||||
uint8_t MaxNumMergeCand;
|
||||
int8_t slice_cb_qp_offset;
|
||||
int8_t slice_cr_qp_offset;
|
||||
int8_t slice_beta_offset_div2;
|
||||
int8_t slice_tc_offset_div2;
|
||||
int8_t slice_act_y_qp_offset;
|
||||
int8_t slice_act_cb_qp_offset;
|
||||
int8_t slice_act_cr_qp_offset;
|
||||
const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet;
|
||||
const StdVideoEncodeH265SliceSegmentLongTermRefPics* pLongTermRefPics;
|
||||
const StdVideoEncodeH265WeightTable* pWeightTable;
|
||||
} StdVideoEncodeH265SliceSegmentHeader;
|
||||
|
||||
typedef struct StdVideoEncodeH265ReferenceListsInfoFlags {
|
||||
uint32_t ref_pic_list_modification_flag_l0 : 1;
|
||||
uint32_t ref_pic_list_modification_flag_l1 : 1;
|
||||
} StdVideoEncodeH265ReferenceListsInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH265ReferenceListsInfo {
|
||||
StdVideoEncodeH265ReferenceListsInfoFlags flags;
|
||||
uint8_t num_ref_idx_l0_active_minus1;
|
||||
uint8_t num_ref_idx_l1_active_minus1;
|
||||
uint16_t reserved1;
|
||||
const uint8_t* pRefPicList0Entries;
|
||||
const uint8_t* pRefPicList1Entries;
|
||||
const uint8_t* pRefList0Modifications;
|
||||
const uint8_t* pRefList1Modifications;
|
||||
} StdVideoEncodeH265ReferenceListsInfo;
|
||||
|
||||
typedef struct StdVideoEncodeH265PictureInfoFlags {
|
||||
uint32_t is_reference_flag : 1;
|
||||
uint32_t IrapPicFlag : 1;
|
||||
uint32_t long_term_flag : 1;
|
||||
uint32_t discardable_flag : 1;
|
||||
uint32_t cross_layer_bla_flag : 1;
|
||||
} StdVideoEncodeH265PictureInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH265PictureInfo {
|
||||
StdVideoEncodeH265PictureInfoFlags flags;
|
||||
StdVideoH265PictureType pic_type;
|
||||
uint8_t sps_video_parameter_set_id;
|
||||
uint8_t pps_seq_parameter_set_id;
|
||||
uint8_t pps_pic_parameter_set_id;
|
||||
uint8_t short_term_ref_pic_set_idx;
|
||||
int32_t PicOrderCntVal;
|
||||
uint8_t TemporalId;
|
||||
uint8_t reserved1[7];
|
||||
const StdVideoEncodeH265ReferenceListsInfo* pRefLists;
|
||||
const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet;
|
||||
const StdVideoEncodeH265LongTermRefPics* pLongTermRefPics;
|
||||
StdVideoEncodeH265PictureInfoFlags flags;
|
||||
StdVideoH265PictureType PictureType;
|
||||
uint8_t sps_video_parameter_set_id;
|
||||
uint8_t pps_seq_parameter_set_id;
|
||||
uint8_t pps_pic_parameter_set_id;
|
||||
uint8_t TemporalId;
|
||||
int32_t PicOrderCntVal;
|
||||
} StdVideoEncodeH265PictureInfo;
|
||||
|
||||
typedef struct StdVideoEncodeH265ReferenceInfoFlags {
|
||||
uint32_t used_for_long_term_reference : 1;
|
||||
uint32_t unused_for_reference : 1;
|
||||
uint32_t reserved : 30;
|
||||
} StdVideoEncodeH265ReferenceInfoFlags;
|
||||
|
||||
typedef struct StdVideoEncodeH265ReferenceInfo {
|
||||
StdVideoEncodeH265ReferenceInfoFlags flags;
|
||||
StdVideoH265PictureType pic_type;
|
||||
StdVideoH265PictureType PictureType;
|
||||
int32_t PicOrderCntVal;
|
||||
uint8_t TemporalId;
|
||||
} StdVideoEncodeH265ReferenceInfo;
|
||||
|
||||
+1
-6
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VIDEO_CODECS_COMMON_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,12 +19,7 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// vulkan_video_codecs_common is a preprocessor guard. Do not pass it to API calls.
|
||||
#define vulkan_video_codecs_common 1
|
||||
#if !defined(VK_NO_STDINT_H)
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
|
||||
#define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \
|
||||
((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
|
||||
|
||||
|
||||
+18
-4
@@ -1,9 +1,23 @@
|
||||
//
|
||||
// File: vk_icd.h
|
||||
//
|
||||
/*
|
||||
* Copyright 2015-2023 The Khronos Group Inc.
|
||||
* Copyright 2015-2023 Valve Corporation
|
||||
* Copyright 2015-2023 LunarG, Inc.
|
||||
* Copyright (c) 2015-2023 LunarG, Inc.
|
||||
* Copyright (c) 2015-2023 The Khronos Group Inc.
|
||||
* Copyright (c) 2015-2023 Valve Corporation
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
|
||||
+18
-4
@@ -1,9 +1,23 @@
|
||||
//
|
||||
// File: vk_layer.h
|
||||
//
|
||||
/*
|
||||
* Copyright 2015-2023 The Khronos Group Inc.
|
||||
* Copyright 2015-2023 Valve Corporation
|
||||
* Copyright 2015-2023 LunarG, Inc.
|
||||
* Copyright (c) 2015-2023 LunarG, Inc.
|
||||
* Copyright (c) 2015-2023 The Khronos Group Inc.
|
||||
* Copyright (c) 2015-2023 Valve Corporation
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
// File: vk_platform.h
|
||||
//
|
||||
/*
|
||||
** Copyright 2014-2024 The Khronos Group Inc.
|
||||
** Copyright 2014-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
+1
-29
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_ANDROID_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_KHR_android_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_android_surface 1
|
||||
struct ANativeWindow;
|
||||
#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
|
||||
@@ -43,7 +42,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_ANDROID_external_memory_android_hardware_buffer is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_ANDROID_external_memory_android_hardware_buffer 1
|
||||
struct AHardwareBuffer;
|
||||
#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 5
|
||||
@@ -120,32 +118,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
|
||||
struct AHardwareBuffer** pBuffer);
|
||||
#endif
|
||||
|
||||
|
||||
// VK_ANDROID_external_format_resolve is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_ANDROID_external_format_resolve 1
|
||||
#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION 1
|
||||
#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME "VK_ANDROID_external_format_resolve"
|
||||
typedef struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 externalFormatResolve;
|
||||
} VkPhysicalDeviceExternalFormatResolveFeaturesANDROID;
|
||||
|
||||
typedef struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 nullColorAttachmentWithExternalFormatResolve;
|
||||
VkChromaLocation externalFormatResolveChromaOffsetX;
|
||||
VkChromaLocation externalFormatResolveChromaOffsetY;
|
||||
} VkPhysicalDeviceExternalFormatResolvePropertiesANDROID;
|
||||
|
||||
typedef struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkFormat colorAttachmentFormat;
|
||||
} VkAndroidHardwareBufferFormatResolvePropertiesANDROID;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
+429
-108
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_BETA_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_KHR_portability_subset is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_portability_subset 1
|
||||
#define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1
|
||||
#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset"
|
||||
@@ -51,122 +50,444 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
|
||||
|
||||
|
||||
|
||||
// VK_AMDX_shader_enqueue is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_AMDX_shader_enqueue 1
|
||||
#define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 1
|
||||
#define VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME "VK_AMDX_shader_enqueue"
|
||||
#define VK_SHADER_INDEX_UNUSED_AMDX (~0U)
|
||||
typedef struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX {
|
||||
#define VK_KHR_video_encode_queue 1
|
||||
#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 8
|
||||
#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
|
||||
|
||||
typedef enum VkVideoEncodeTuningModeKHR {
|
||||
VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0,
|
||||
VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1,
|
||||
VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2,
|
||||
VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3,
|
||||
VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4,
|
||||
VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeTuningModeKHR;
|
||||
typedef VkFlags VkVideoEncodeFlagsKHR;
|
||||
|
||||
typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
|
||||
VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001,
|
||||
VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeCapabilityFlagBitsKHR;
|
||||
typedef VkFlags VkVideoEncodeCapabilityFlagsKHR;
|
||||
|
||||
typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {
|
||||
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0,
|
||||
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001,
|
||||
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002,
|
||||
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004,
|
||||
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeRateControlModeFlagBitsKHR;
|
||||
typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
|
||||
|
||||
typedef enum VkVideoEncodeFeedbackFlagBitsKHR {
|
||||
VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001,
|
||||
VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002,
|
||||
VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeFeedbackFlagBitsKHR;
|
||||
typedef VkFlags VkVideoEncodeFeedbackFlagsKHR;
|
||||
|
||||
typedef enum VkVideoEncodeUsageFlagBitsKHR {
|
||||
VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0,
|
||||
VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001,
|
||||
VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002,
|
||||
VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004,
|
||||
VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008,
|
||||
VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeUsageFlagBitsKHR;
|
||||
typedef VkFlags VkVideoEncodeUsageFlagsKHR;
|
||||
|
||||
typedef enum VkVideoEncodeContentFlagBitsKHR {
|
||||
VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0,
|
||||
VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001,
|
||||
VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002,
|
||||
VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004,
|
||||
VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
|
||||
} VkVideoEncodeContentFlagBitsKHR;
|
||||
typedef VkFlags VkVideoEncodeContentFlagsKHR;
|
||||
typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
|
||||
typedef struct VkVideoEncodeInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkVideoEncodeFlagsKHR flags;
|
||||
uint32_t qualityLevel;
|
||||
VkBuffer dstBuffer;
|
||||
VkDeviceSize dstBufferOffset;
|
||||
VkDeviceSize dstBufferRange;
|
||||
VkVideoPictureResourceInfoKHR srcPictureResource;
|
||||
const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot;
|
||||
uint32_t referenceSlotCount;
|
||||
const VkVideoReferenceSlotInfoKHR* pReferenceSlots;
|
||||
uint32_t precedingExternallyEncodedBytes;
|
||||
} VkVideoEncodeInfoKHR;
|
||||
|
||||
typedef struct VkVideoEncodeCapabilitiesKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkVideoEncodeCapabilityFlagsKHR flags;
|
||||
VkVideoEncodeRateControlModeFlagsKHR rateControlModes;
|
||||
uint32_t maxRateControlLayers;
|
||||
uint32_t maxQualityLevels;
|
||||
VkExtent2D inputImageDataFillAlignment;
|
||||
VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags;
|
||||
} VkVideoEncodeCapabilitiesKHR;
|
||||
|
||||
typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags;
|
||||
} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR;
|
||||
|
||||
typedef struct VkVideoEncodeUsageInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkVideoEncodeUsageFlagsKHR videoUsageHints;
|
||||
VkVideoEncodeContentFlagsKHR videoContentHints;
|
||||
VkVideoEncodeTuningModeKHR tuningMode;
|
||||
} VkVideoEncodeUsageInfoKHR;
|
||||
|
||||
typedef struct VkVideoEncodeRateControlLayerInfoKHR {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 shaderEnqueue;
|
||||
} VkPhysicalDeviceShaderEnqueueFeaturesAMDX;
|
||||
const void* pNext;
|
||||
uint64_t averageBitrate;
|
||||
uint64_t maxBitrate;
|
||||
uint32_t frameRateNumerator;
|
||||
uint32_t frameRateDenominator;
|
||||
uint32_t virtualBufferSizeInMs;
|
||||
uint32_t initialVirtualBufferSizeInMs;
|
||||
} VkVideoEncodeRateControlLayerInfoKHR;
|
||||
|
||||
typedef struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
uint32_t maxExecutionGraphDepth;
|
||||
uint32_t maxExecutionGraphShaderOutputNodes;
|
||||
uint32_t maxExecutionGraphShaderPayloadSize;
|
||||
uint32_t maxExecutionGraphShaderPayloadCount;
|
||||
uint32_t executionGraphDispatchAddressAlignment;
|
||||
} VkPhysicalDeviceShaderEnqueuePropertiesAMDX;
|
||||
typedef struct VkVideoEncodeRateControlInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkVideoEncodeRateControlFlagsKHR flags;
|
||||
VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
|
||||
uint32_t layerCount;
|
||||
const VkVideoEncodeRateControlLayerInfoKHR* pLayers;
|
||||
} VkVideoEncodeRateControlInfoKHR;
|
||||
|
||||
typedef struct VkExecutionGraphPipelineScratchSizeAMDX {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkDeviceSize size;
|
||||
} VkExecutionGraphPipelineScratchSizeAMDX;
|
||||
|
||||
typedef struct VkExecutionGraphPipelineCreateInfoAMDX {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkPipelineCreateFlags flags;
|
||||
uint32_t stageCount;
|
||||
const VkPipelineShaderStageCreateInfo* pStages;
|
||||
const VkPipelineLibraryCreateInfoKHR* pLibraryInfo;
|
||||
VkPipelineLayout layout;
|
||||
VkPipeline basePipelineHandle;
|
||||
int32_t basePipelineIndex;
|
||||
} VkExecutionGraphPipelineCreateInfoAMDX;
|
||||
|
||||
typedef union VkDeviceOrHostAddressConstAMDX {
|
||||
VkDeviceAddress deviceAddress;
|
||||
const void* hostAddress;
|
||||
} VkDeviceOrHostAddressConstAMDX;
|
||||
|
||||
typedef struct VkDispatchGraphInfoAMDX {
|
||||
uint32_t nodeIndex;
|
||||
uint32_t payloadCount;
|
||||
VkDeviceOrHostAddressConstAMDX payloads;
|
||||
uint64_t payloadStride;
|
||||
} VkDispatchGraphInfoAMDX;
|
||||
|
||||
typedef struct VkDispatchGraphCountInfoAMDX {
|
||||
uint32_t count;
|
||||
VkDeviceOrHostAddressConstAMDX infos;
|
||||
uint64_t stride;
|
||||
} VkDispatchGraphCountInfoAMDX;
|
||||
|
||||
typedef struct VkPipelineShaderStageNodeCreateInfoAMDX {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const char* pName;
|
||||
uint32_t index;
|
||||
} VkPipelineShaderStageNodeCreateInfoAMDX;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkCreateExecutionGraphPipelinesAMDX)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineScratchSizeAMDX)(VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo);
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineNodeIndexAMDX)(VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, const VkDispatchGraphCountInfoAMDX* pCountInfo);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, const VkDispatchGraphCountInfoAMDX* pCountInfo);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceAddress countInfo);
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(
|
||||
VkDevice device,
|
||||
VkPipelineCache pipelineCache,
|
||||
uint32_t createInfoCount,
|
||||
const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos,
|
||||
const VkAllocationCallbacks* pAllocator,
|
||||
VkPipeline* pPipelines);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX(
|
||||
VkDevice device,
|
||||
VkPipeline executionGraph,
|
||||
VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo);
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX(
|
||||
VkDevice device,
|
||||
VkPipeline executionGraph,
|
||||
const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo,
|
||||
uint32_t* pNodeIndex);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX(
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
|
||||
VkCommandBuffer commandBuffer,
|
||||
VkDeviceAddress scratch);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX(
|
||||
VkCommandBuffer commandBuffer,
|
||||
VkDeviceAddress scratch,
|
||||
const VkDispatchGraphCountInfoAMDX* pCountInfo);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX(
|
||||
VkCommandBuffer commandBuffer,
|
||||
VkDeviceAddress scratch,
|
||||
const VkDispatchGraphCountInfoAMDX* pCountInfo);
|
||||
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(
|
||||
VkCommandBuffer commandBuffer,
|
||||
VkDeviceAddress scratch,
|
||||
VkDeviceAddress countInfo);
|
||||
const VkVideoEncodeInfoKHR* pEncodeInfo);
|
||||
#endif
|
||||
|
||||
|
||||
// VK_NV_displacement_micromap is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_video_encode_h264 1
|
||||
#include "vk_video/vulkan_video_codec_h264std.h"
|
||||
#include "vk_video/vulkan_video_codec_h264std_encode.h"
|
||||
#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 10
|
||||
#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
|
||||
|
||||
typedef enum VkVideoEncodeH264RateControlStructureEXT {
|
||||
VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0,
|
||||
VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1,
|
||||
VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2,
|
||||
VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkVideoEncodeH264RateControlStructureEXT;
|
||||
|
||||
typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT = 0x00000001,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT = 0x00000002,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000004,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT = 0x00000008,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000010,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000040,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000080,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000100,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00000200,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT = 0x00000400,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT = 0x00000800,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00001000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00002000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00004000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00008000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00010000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00020000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00040000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT = 0x00080000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00100000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT = 0x00200000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00400000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00800000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x01000000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_REFERENCE_FINAL_LISTS_BIT_EXT = 0x02000000,
|
||||
VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkVideoEncodeH264CapabilityFlagBitsEXT;
|
||||
typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT;
|
||||
typedef struct VkVideoEncodeH264CapabilitiesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkVideoEncodeH264CapabilityFlagsEXT flags;
|
||||
uint32_t maxPPictureL0ReferenceCount;
|
||||
uint32_t maxBPictureL0ReferenceCount;
|
||||
uint32_t maxL1ReferenceCount;
|
||||
VkBool32 motionVectorsOverPicBoundariesFlag;
|
||||
uint32_t maxBytesPerPicDenom;
|
||||
uint32_t maxBitsPerMbDenom;
|
||||
uint32_t log2MaxMvLengthHorizontal;
|
||||
uint32_t log2MaxMvLengthVertical;
|
||||
} VkVideoEncodeH264CapabilitiesEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t stdSPSCount;
|
||||
const StdVideoH264SequenceParameterSet* pStdSPSs;
|
||||
uint32_t stdPPSCount;
|
||||
const StdVideoH264PictureParameterSet* pStdPPSs;
|
||||
} VkVideoEncodeH264SessionParametersAddInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t maxStdSPSCount;
|
||||
uint32_t maxStdPPSCount;
|
||||
const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo;
|
||||
} VkVideoEncodeH264SessionParametersCreateInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264NaluSliceInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t mbCount;
|
||||
const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists;
|
||||
const StdVideoEncodeH264SliceHeader* pStdSliceHeader;
|
||||
} VkVideoEncodeH264NaluSliceInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264VclFrameInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists;
|
||||
uint32_t naluSliceEntryCount;
|
||||
const VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries;
|
||||
const StdVideoEncodeH264PictureInfo* pStdPictureInfo;
|
||||
} VkVideoEncodeH264VclFrameInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264DpbSlotInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo;
|
||||
} VkVideoEncodeH264DpbSlotInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264ProfileInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
StdVideoH264ProfileIdc stdProfileIdc;
|
||||
} VkVideoEncodeH264ProfileInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264RateControlInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t gopFrameCount;
|
||||
uint32_t idrPeriod;
|
||||
uint32_t consecutiveBFrameCount;
|
||||
VkVideoEncodeH264RateControlStructureEXT rateControlStructure;
|
||||
uint32_t temporalLayerCount;
|
||||
} VkVideoEncodeH264RateControlInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264QpEXT {
|
||||
int32_t qpI;
|
||||
int32_t qpP;
|
||||
int32_t qpB;
|
||||
} VkVideoEncodeH264QpEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264FrameSizeEXT {
|
||||
uint32_t frameISize;
|
||||
uint32_t framePSize;
|
||||
uint32_t frameBSize;
|
||||
} VkVideoEncodeH264FrameSizeEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH264RateControlLayerInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t temporalLayerId;
|
||||
VkBool32 useInitialRcQp;
|
||||
VkVideoEncodeH264QpEXT initialRcQp;
|
||||
VkBool32 useMinQp;
|
||||
VkVideoEncodeH264QpEXT minQp;
|
||||
VkBool32 useMaxQp;
|
||||
VkVideoEncodeH264QpEXT maxQp;
|
||||
VkBool32 useMaxFrameSize;
|
||||
VkVideoEncodeH264FrameSizeEXT maxFrameSize;
|
||||
} VkVideoEncodeH264RateControlLayerInfoEXT;
|
||||
|
||||
|
||||
|
||||
#define VK_EXT_video_encode_h265 1
|
||||
#include "vk_video/vulkan_video_codec_h265std.h"
|
||||
#include "vk_video/vulkan_video_codec_h265std_encode.h"
|
||||
#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 10
|
||||
#define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265"
|
||||
|
||||
typedef enum VkVideoEncodeH265RateControlStructureEXT {
|
||||
VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0,
|
||||
VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1,
|
||||
VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2,
|
||||
VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkVideoEncodeH265RateControlStructureEXT;
|
||||
|
||||
typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT {
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000001,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000002,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT = 0x00000004,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT = 0x00000008,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT = 0x00000010,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT = 0x00000040,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000080,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0x00000100,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0x00000200,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0x00000400,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0x00000800,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00001000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0x00002000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00004000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0x00008000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0x00010000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0x00020000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0x00040000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0x00080000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0x00100000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0x00200000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00400000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0x00800000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x01000000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x02000000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_REFERENCE_FINAL_LISTS_BIT_EXT = 0x04000000,
|
||||
VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkVideoEncodeH265CapabilityFlagBitsEXT;
|
||||
typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT;
|
||||
|
||||
typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT {
|
||||
VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001,
|
||||
VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002,
|
||||
VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0x00000004,
|
||||
VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkVideoEncodeH265CtbSizeFlagBitsEXT;
|
||||
typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT;
|
||||
|
||||
typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT {
|
||||
VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0x00000001,
|
||||
VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0x00000002,
|
||||
VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0x00000004,
|
||||
VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0x00000008,
|
||||
VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
|
||||
} VkVideoEncodeH265TransformBlockSizeFlagBitsEXT;
|
||||
typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT;
|
||||
typedef struct VkVideoEncodeH265CapabilitiesEXT {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkVideoEncodeH265CapabilityFlagsEXT flags;
|
||||
VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes;
|
||||
VkVideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes;
|
||||
uint32_t maxPPictureL0ReferenceCount;
|
||||
uint32_t maxBPictureL0ReferenceCount;
|
||||
uint32_t maxL1ReferenceCount;
|
||||
uint32_t maxSubLayersCount;
|
||||
uint32_t minLog2MinLumaCodingBlockSizeMinus3;
|
||||
uint32_t maxLog2MinLumaCodingBlockSizeMinus3;
|
||||
uint32_t minLog2MinLumaTransformBlockSizeMinus2;
|
||||
uint32_t maxLog2MinLumaTransformBlockSizeMinus2;
|
||||
uint32_t minMaxTransformHierarchyDepthInter;
|
||||
uint32_t maxMaxTransformHierarchyDepthInter;
|
||||
uint32_t minMaxTransformHierarchyDepthIntra;
|
||||
uint32_t maxMaxTransformHierarchyDepthIntra;
|
||||
uint32_t maxDiffCuQpDeltaDepth;
|
||||
uint32_t minMaxNumMergeCand;
|
||||
uint32_t maxMaxNumMergeCand;
|
||||
} VkVideoEncodeH265CapabilitiesEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t stdVPSCount;
|
||||
const StdVideoH265VideoParameterSet* pStdVPSs;
|
||||
uint32_t stdSPSCount;
|
||||
const StdVideoH265SequenceParameterSet* pStdSPSs;
|
||||
uint32_t stdPPSCount;
|
||||
const StdVideoH265PictureParameterSet* pStdPPSs;
|
||||
} VkVideoEncodeH265SessionParametersAddInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t maxStdVPSCount;
|
||||
uint32_t maxStdSPSCount;
|
||||
uint32_t maxStdPPSCount;
|
||||
const VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo;
|
||||
} VkVideoEncodeH265SessionParametersCreateInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t ctbCount;
|
||||
const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists;
|
||||
const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader;
|
||||
} VkVideoEncodeH265NaluSliceSegmentInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265VclFrameInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists;
|
||||
uint32_t naluSliceSegmentEntryCount;
|
||||
const VkVideoEncodeH265NaluSliceSegmentInfoEXT* pNaluSliceSegmentEntries;
|
||||
const StdVideoEncodeH265PictureInfo* pStdPictureInfo;
|
||||
} VkVideoEncodeH265VclFrameInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265DpbSlotInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo;
|
||||
} VkVideoEncodeH265DpbSlotInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265ProfileInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
StdVideoH265ProfileIdc stdProfileIdc;
|
||||
} VkVideoEncodeH265ProfileInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265RateControlInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t gopFrameCount;
|
||||
uint32_t idrPeriod;
|
||||
uint32_t consecutiveBFrameCount;
|
||||
VkVideoEncodeH265RateControlStructureEXT rateControlStructure;
|
||||
uint32_t subLayerCount;
|
||||
} VkVideoEncodeH265RateControlInfoEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265QpEXT {
|
||||
int32_t qpI;
|
||||
int32_t qpP;
|
||||
int32_t qpB;
|
||||
} VkVideoEncodeH265QpEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265FrameSizeEXT {
|
||||
uint32_t frameISize;
|
||||
uint32_t framePSize;
|
||||
uint32_t frameBSize;
|
||||
} VkVideoEncodeH265FrameSizeEXT;
|
||||
|
||||
typedef struct VkVideoEncodeH265RateControlLayerInfoEXT {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint32_t temporalId;
|
||||
VkBool32 useInitialRcQp;
|
||||
VkVideoEncodeH265QpEXT initialRcQp;
|
||||
VkBool32 useMinQp;
|
||||
VkVideoEncodeH265QpEXT minQp;
|
||||
VkBool32 useMaxQp;
|
||||
VkVideoEncodeH265QpEXT maxQp;
|
||||
VkBool32 useMaxFrameSize;
|
||||
VkVideoEncodeH265FrameSizeEXT maxFrameSize;
|
||||
} VkVideoEncodeH265RateControlLayerInfoEXT;
|
||||
|
||||
|
||||
|
||||
#define VK_NV_displacement_micromap 1
|
||||
#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 2
|
||||
#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 1
|
||||
#define VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME "VK_NV_displacement_micromap"
|
||||
|
||||
typedef enum VkDisplacementMicromapFormatNV {
|
||||
|
||||
+262
-2722
File diff suppressed because it is too large.
Load diff
+1
-2
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_DIRECTFB_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_EXT_directfb_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_directfb_surface 1
|
||||
#define VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION 1
|
||||
#define VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME "VK_EXT_directfb_surface"
|
||||
|
||||
+1
-5
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_FUCHSIA_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_FUCHSIA_imagepipe_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_FUCHSIA_imagepipe_surface 1
|
||||
#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
|
||||
#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface"
|
||||
@@ -42,7 +41,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_FUCHSIA_external_memory is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_FUCHSIA_external_memory 1
|
||||
#define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1
|
||||
#define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory"
|
||||
@@ -83,7 +81,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_FUCHSIA_external_semaphore is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_FUCHSIA_external_semaphore 1
|
||||
#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
|
||||
#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_FUCHSIA_external_semaphore"
|
||||
@@ -118,7 +115,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_FUCHSIA_buffer_collection is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_FUCHSIA_buffer_collection 1
|
||||
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA)
|
||||
#define VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION 2
|
||||
|
||||
+1
-3
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_GGP_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_GGP_stream_descriptor_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_GGP_stream_descriptor_surface 1
|
||||
#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1
|
||||
#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface"
|
||||
@@ -42,7 +41,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_GGP_frame_token is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_GGP_frame_token 1
|
||||
#define VK_GGP_FRAME_TOKEN_SPEC_VERSION 1
|
||||
#define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token"
|
||||
|
||||
+1
-2
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_IOS_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_MVK_ios_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_MVK_ios_surface 1
|
||||
#define VK_MVK_IOS_SURFACE_SPEC_VERSION 3
|
||||
#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
|
||||
|
||||
+1
-2
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_MACOS_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_MVK_macos_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_MVK_macos_surface 1
|
||||
#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 3
|
||||
#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
|
||||
|
||||
+1
-3
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_METAL_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_EXT_metal_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_metal_surface 1
|
||||
#ifdef __OBJC__
|
||||
@class CAMetalLayer;
|
||||
@@ -48,7 +47,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_EXT_metal_objects is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_metal_objects 1
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLDevice;
|
||||
|
||||
+1
-55
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_SCREEN_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_QNX_screen_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_QNX_screen_surface 1
|
||||
#define VK_QNX_SCREEN_SURFACE_SPEC_VERSION 1
|
||||
#define VK_QNX_SCREEN_SURFACE_EXTENSION_NAME "VK_QNX_screen_surface"
|
||||
@@ -48,59 +47,6 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(
|
||||
struct _screen_window* window);
|
||||
#endif
|
||||
|
||||
|
||||
// VK_QNX_external_memory_screen_buffer is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_QNX_external_memory_screen_buffer 1
|
||||
#define VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION 1
|
||||
#define VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME "VK_QNX_external_memory_screen_buffer"
|
||||
typedef struct VkScreenBufferPropertiesQNX {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkDeviceSize allocationSize;
|
||||
uint32_t memoryTypeBits;
|
||||
} VkScreenBufferPropertiesQNX;
|
||||
|
||||
typedef struct VkScreenBufferFormatPropertiesQNX {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkFormat format;
|
||||
uint64_t externalFormat;
|
||||
uint64_t screenUsage;
|
||||
VkFormatFeatureFlags formatFeatures;
|
||||
VkComponentMapping samplerYcbcrConversionComponents;
|
||||
VkSamplerYcbcrModelConversion suggestedYcbcrModel;
|
||||
VkSamplerYcbcrRange suggestedYcbcrRange;
|
||||
VkChromaLocation suggestedXChromaOffset;
|
||||
VkChromaLocation suggestedYChromaOffset;
|
||||
} VkScreenBufferFormatPropertiesQNX;
|
||||
|
||||
typedef struct VkImportScreenBufferInfoQNX {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
struct _screen_buffer* buffer;
|
||||
} VkImportScreenBufferInfoQNX;
|
||||
|
||||
typedef struct VkExternalFormatQNX {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
uint64_t externalFormat;
|
||||
} VkExternalFormatQNX;
|
||||
|
||||
typedef struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
VkBool32 screenBufferImport;
|
||||
} VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
|
||||
|
||||
typedef VkResult (VKAPI_PTR *PFN_vkGetScreenBufferPropertiesQNX)(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX(
|
||||
VkDevice device,
|
||||
const struct _screen_buffer* buffer,
|
||||
VkScreenBufferPropertiesQNX* pProperties);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
+1
-2
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VI_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_NN_vi_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NN_vi_surface 1
|
||||
#define VK_NN_VI_SURFACE_SPEC_VERSION 1
|
||||
#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface"
|
||||
|
||||
+1
-2
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_WAYLAND_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_KHR_wayland_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_wayland_surface 1
|
||||
#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
|
||||
#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
|
||||
|
||||
+1
-10
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_WIN32_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_KHR_win32_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_win32_surface 1
|
||||
#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
|
||||
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
|
||||
@@ -48,7 +47,6 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_external_memory_win32 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_external_memory_win32 1
|
||||
#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
|
||||
#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
|
||||
@@ -98,7 +96,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_win32_keyed_mutex 1
|
||||
#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
|
||||
#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
|
||||
@@ -116,7 +113,6 @@ typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
|
||||
|
||||
|
||||
|
||||
// VK_KHR_external_semaphore_win32 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_external_semaphore_win32 1
|
||||
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
|
||||
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
|
||||
@@ -169,7 +165,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_KHR_external_fence_win32 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_external_fence_win32 1
|
||||
#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
|
||||
#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
|
||||
@@ -213,7 +208,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_NV_external_memory_win32 is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_external_memory_win32 1
|
||||
#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
|
||||
#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
|
||||
@@ -242,7 +236,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_NV_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_win32_keyed_mutex 1
|
||||
#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
|
||||
#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
|
||||
@@ -260,7 +253,6 @@ typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
|
||||
|
||||
|
||||
|
||||
// VK_EXT_full_screen_exclusive is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_full_screen_exclusive 1
|
||||
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
|
||||
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
|
||||
@@ -317,7 +309,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
|
||||
#endif
|
||||
|
||||
|
||||
// VK_NV_acquire_winrt_display is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_acquire_winrt_display 1
|
||||
#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1
|
||||
#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"
|
||||
|
||||
+1
-2
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_XCB_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_KHR_xcb_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_xcb_surface 1
|
||||
#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6
|
||||
#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
|
||||
|
||||
+1
-2
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_XLIB_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_KHR_xlib_surface is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_KHR_xlib_surface 1
|
||||
#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6
|
||||
#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
|
||||
|
||||
Vendored
+1
-2
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_XLIB_XRANDR_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,7 +19,6 @@ extern "C" {
|
||||
|
||||
|
||||
|
||||
// VK_EXT_acquire_xlib_display is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_EXT_acquire_xlib_display 1
|
||||
#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
|
||||
#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
|
||||
|
||||
@@ -57,7 +57,6 @@ struct BufferCreateInfo
|
||||
BufferMiscFlags misc = 0;
|
||||
VkMemoryRequirements allocation_requirements = {};
|
||||
ExternalHandle external;
|
||||
void *pnext = nullptr;
|
||||
};
|
||||
|
||||
class Buffer;
|
||||
|
||||
@@ -28,12 +28,14 @@
|
||||
namespace Vulkan
|
||||
{
|
||||
void BufferPool::init(Device *device_, VkDeviceSize block_size_,
|
||||
VkDeviceSize alignment_, VkBufferUsageFlags usage_)
|
||||
VkDeviceSize alignment_, VkBufferUsageFlags usage_,
|
||||
bool need_device_local_)
|
||||
{
|
||||
device = device_;
|
||||
block_size = block_size_;
|
||||
alignment = alignment_;
|
||||
usage = usage_;
|
||||
need_device_local = need_device_local_;
|
||||
}
|
||||
|
||||
void BufferPool::set_spill_region_size(VkDeviceSize spill_size_)
|
||||
@@ -57,22 +59,40 @@ void BufferPool::reset()
|
||||
|
||||
BufferBlock BufferPool::allocate_block(VkDeviceSize size)
|
||||
{
|
||||
BufferDomain ideal_domain = ((usage & VK_BUFFER_USAGE_TRANSFER_SRC_BIT) != 0) ?
|
||||
BufferDomain::Host : BufferDomain::LinkedDeviceHost;
|
||||
BufferDomain ideal_domain = need_device_local ?
|
||||
BufferDomain::Device :
|
||||
((usage & VK_BUFFER_USAGE_TRANSFER_SRC_BIT) != 0) ? BufferDomain::Host : BufferDomain::LinkedDeviceHost;
|
||||
|
||||
VkBufferUsageFlags extra_usage = ideal_domain == BufferDomain::Device ? VK_BUFFER_USAGE_TRANSFER_DST_BIT : 0;
|
||||
|
||||
BufferBlock block;
|
||||
|
||||
BufferCreateInfo info;
|
||||
info.domain = ideal_domain;
|
||||
info.size = size;
|
||||
info.usage = usage;
|
||||
info.usage = usage | extra_usage;
|
||||
|
||||
block.buffer = device->create_buffer(info, nullptr);
|
||||
device->set_name(*block.buffer, "chain-allocated-block");
|
||||
block.buffer->set_internal_sync_object();
|
||||
block.gpu = device->create_buffer(info, nullptr);
|
||||
device->set_name(*block.gpu, "chain-allocated-block-gpu");
|
||||
block.gpu->set_internal_sync_object();
|
||||
|
||||
// Try to map it, will fail unless the memory is host visible.
|
||||
block.mapped = static_cast<uint8_t *>(device->map_host_buffer(*block.buffer, MEMORY_ACCESS_WRITE_BIT));
|
||||
block.mapped = static_cast<uint8_t *>(device->map_host_buffer(*block.gpu, MEMORY_ACCESS_WRITE_BIT));
|
||||
if (!block.mapped)
|
||||
{
|
||||
// Fall back to host memory, and remember to sync to gpu on submission time using DMA queue. :)
|
||||
BufferCreateInfo cpu_info;
|
||||
cpu_info.domain = BufferDomain::Host;
|
||||
cpu_info.size = size;
|
||||
cpu_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
||||
|
||||
block.cpu = device->create_buffer(cpu_info, nullptr);
|
||||
block.cpu->set_internal_sync_object();
|
||||
device->set_name(*block.cpu, "chain-allocated-block-cpu");
|
||||
block.mapped = static_cast<uint8_t *>(device->map_host_buffer(*block.cpu, MEMORY_ACCESS_WRITE_BIT));
|
||||
}
|
||||
else
|
||||
block.cpu = block.gpu;
|
||||
|
||||
block.offset = 0;
|
||||
block.alignment = alignment;
|
||||
@@ -92,7 +112,7 @@ BufferBlock BufferPool::request_block(VkDeviceSize minimum_size)
|
||||
auto back = std::move(blocks.back());
|
||||
blocks.pop_back();
|
||||
|
||||
back.mapped = static_cast<uint8_t *>(device->map_host_buffer(*back.buffer, MEMORY_ACCESS_WRITE_BIT));
|
||||
back.mapped = static_cast<uint8_t *>(device->map_host_buffer(*back.cpu, MEMORY_ACCESS_WRITE_BIT));
|
||||
back.offset = 0;
|
||||
return back;
|
||||
}
|
||||
@@ -113,26 +133,4 @@ BufferPool::~BufferPool()
|
||||
VK_ASSERT(blocks.empty());
|
||||
}
|
||||
|
||||
BufferBlockAllocation BufferBlock::allocate(VkDeviceSize allocate_size)
|
||||
{
|
||||
auto aligned_offset = (offset + alignment - 1) & ~(alignment - 1);
|
||||
if (aligned_offset + allocate_size <= size)
|
||||
{
|
||||
auto *ret = mapped + aligned_offset;
|
||||
offset = aligned_offset + allocate_size;
|
||||
|
||||
VkDeviceSize padded_size = std::max<VkDeviceSize>(allocate_size, spill_size);
|
||||
padded_size = std::min<VkDeviceSize>(padded_size, size - aligned_offset);
|
||||
|
||||
return { ret, buffer, aligned_offset, padded_size };
|
||||
}
|
||||
else
|
||||
return { nullptr, {}, 0, 0 };
|
||||
}
|
||||
|
||||
void BufferBlock::unmap(Device &device)
|
||||
{
|
||||
device.unmap_host_buffer(*buffer, MEMORY_ACCESS_WRITE_BIT);
|
||||
mapped = nullptr;
|
||||
}
|
||||
}
|
||||
@@ -35,39 +35,44 @@ class Buffer;
|
||||
struct BufferBlockAllocation
|
||||
{
|
||||
uint8_t *host;
|
||||
Util::IntrusivePtr<Buffer> buffer;
|
||||
VkDeviceSize offset;
|
||||
VkDeviceSize padded_size;
|
||||
};
|
||||
|
||||
class BufferBlock
|
||||
struct BufferBlock
|
||||
{
|
||||
public:
|
||||
~BufferBlock();
|
||||
|
||||
BufferBlockAllocation allocate(VkDeviceSize allocate_size);
|
||||
inline bool is_mapped() const { return mapped != nullptr; }
|
||||
const Buffer &get_buffer() const { return *buffer; }
|
||||
void unmap(Device &device);
|
||||
|
||||
inline VkDeviceSize get_offset() const { return offset; }
|
||||
inline VkDeviceSize get_size() const { return size; }
|
||||
|
||||
private:
|
||||
friend class BufferPool;
|
||||
Util::IntrusivePtr<Buffer> buffer;
|
||||
Util::IntrusivePtr<Buffer> gpu;
|
||||
Util::IntrusivePtr<Buffer> cpu;
|
||||
VkDeviceSize offset = 0;
|
||||
VkDeviceSize alignment = 0;
|
||||
VkDeviceSize size = 0;
|
||||
VkDeviceSize spill_size = 0;
|
||||
uint8_t *mapped = nullptr;
|
||||
|
||||
BufferBlockAllocation allocate(VkDeviceSize allocate_size)
|
||||
{
|
||||
auto aligned_offset = (offset + alignment - 1) & ~(alignment - 1);
|
||||
if (aligned_offset + allocate_size <= size)
|
||||
{
|
||||
auto *ret = mapped + aligned_offset;
|
||||
offset = aligned_offset + allocate_size;
|
||||
|
||||
VkDeviceSize padded_size = std::max<VkDeviceSize>(allocate_size, spill_size);
|
||||
padded_size = std::min<VkDeviceSize>(padded_size, size - aligned_offset);
|
||||
|
||||
return { ret, aligned_offset, padded_size };
|
||||
}
|
||||
else
|
||||
return { nullptr, 0, 0 };
|
||||
}
|
||||
};
|
||||
|
||||
class BufferPool
|
||||
{
|
||||
public:
|
||||
~BufferPool();
|
||||
void init(Device *device, VkDeviceSize block_size, VkDeviceSize alignment, VkBufferUsageFlags usage);
|
||||
void init(Device *device, VkDeviceSize block_size, VkDeviceSize alignment, VkBufferUsageFlags usage, bool need_device_local);
|
||||
void reset();
|
||||
|
||||
// Used for allocating UBOs, where we want to specify a fixed size for range,
|
||||
@@ -92,5 +97,6 @@ private:
|
||||
size_t max_retained_blocks = 0;
|
||||
std::vector<BufferBlock> blocks;
|
||||
BufferBlock allocate_block(VkDeviceSize size);
|
||||
bool need_device_local = false;
|
||||
};
|
||||
}
|
||||
+169
-157
@@ -56,18 +56,18 @@ CommandBuffer::CommandBuffer(Device *device_, VkCommandBuffer cmd_, VkPipelineCa
|
||||
// This needs to affect hashing to make Fossilize path behave as expected.
|
||||
auto &features = device->get_device_features();
|
||||
pipeline_state.subgroup_size_tag =
|
||||
(features.vk13_props.minSubgroupSize << 0) |
|
||||
(features.vk13_props.maxSubgroupSize << 8);
|
||||
(features.subgroup_size_control_properties.minSubgroupSize << 0) |
|
||||
(features.subgroup_size_control_properties.maxSubgroupSize << 8);
|
||||
|
||||
device->lock.read_only_cache.lock_read();
|
||||
}
|
||||
|
||||
CommandBuffer::~CommandBuffer()
|
||||
{
|
||||
VK_ASSERT(!vbo_block.is_mapped());
|
||||
VK_ASSERT(!ibo_block.is_mapped());
|
||||
VK_ASSERT(!ubo_block.is_mapped());
|
||||
VK_ASSERT(!staging_block.is_mapped());
|
||||
VK_ASSERT(vbo_block.mapped == nullptr);
|
||||
VK_ASSERT(ibo_block.mapped == nullptr);
|
||||
VK_ASSERT(ubo_block.mapped == nullptr);
|
||||
VK_ASSERT(staging_block.mapped == nullptr);
|
||||
device->lock.read_only_cache.unlock_read();
|
||||
}
|
||||
|
||||
@@ -394,7 +394,7 @@ void CommandBuffer::barrier(const VkDependencyInfo &dep)
|
||||
}
|
||||
#endif
|
||||
|
||||
if (device->get_device_features().vk13_features.synchronization2)
|
||||
if (device->get_device_features().sync2_features.synchronization2)
|
||||
{
|
||||
Util::SmallVector<VkBufferMemoryBarrier2> tmp_buffer;
|
||||
Util::SmallVector<VkImageMemoryBarrier2> tmp_image;
|
||||
@@ -458,7 +458,7 @@ void CommandBuffer::barrier(const VkDependencyInfo &dep)
|
||||
}
|
||||
}
|
||||
|
||||
table.vkCmdPipelineBarrier2(cmd, final_dep);
|
||||
table.vkCmdPipelineBarrier2KHR(cmd, final_dep);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -523,7 +523,8 @@ static uint32_t deduce_acquire_release_family_index(Device &device, const Image
|
||||
if (queue_info.family_indices[QUEUE_INDEX_GRAPHICS] != family)
|
||||
return VK_QUEUE_FAMILY_IGNORED;
|
||||
|
||||
if (image.get_create_info().misc & IMAGE_MISC_CONCURRENT_QUEUE_ASYNC_COMPUTE_BIT)
|
||||
if (image.get_create_info().misc &
|
||||
(IMAGE_MISC_CONCURRENT_QUEUE_ASYNC_GRAPHICS_BIT | IMAGE_MISC_CONCURRENT_QUEUE_ASYNC_COMPUTE_BIT))
|
||||
{
|
||||
if (queue_info.family_indices[QUEUE_INDEX_COMPUTE] != family)
|
||||
return VK_QUEUE_FAMILY_IGNORED;
|
||||
@@ -536,11 +537,10 @@ static uint32_t deduce_acquire_release_family_index(Device &device, const Image
|
||||
return family;
|
||||
}
|
||||
|
||||
void CommandBuffer::release_image_barrier(
|
||||
void CommandBuffer::release_external_image_barrier(
|
||||
const Image &image,
|
||||
VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access,
|
||||
uint32_t dst_queue_family)
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access)
|
||||
{
|
||||
VkImageMemoryBarrier2 barrier = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
|
||||
uint32_t family_index = device->get_queue_info().family_indices[device->get_physical_queue_type(type)];
|
||||
@@ -553,21 +553,20 @@ void CommandBuffer::release_image_barrier(
|
||||
};
|
||||
barrier.oldLayout = old_layout;
|
||||
barrier.newLayout = new_layout;
|
||||
barrier.srcAccessMask = src_access;
|
||||
|
||||
barrier.srcQueueFamilyIndex = deduce_acquire_release_family_index(*device, image, family_index);
|
||||
barrier.dstQueueFamilyIndex = dst_queue_family;
|
||||
|
||||
barrier.srcAccessMask = src_access;
|
||||
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL;
|
||||
barrier.srcStageMask = src_stage;
|
||||
barrier.dstStageMask = VK_PIPELINE_STAGE_NONE;
|
||||
|
||||
image_barriers(1, &barrier);
|
||||
}
|
||||
|
||||
void CommandBuffer::acquire_image_barrier(
|
||||
void CommandBuffer::acquire_external_image_barrier(
|
||||
const Image &image,
|
||||
VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access,
|
||||
uint32_t src_queue_family)
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access)
|
||||
{
|
||||
VkImageMemoryBarrier2 b = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
|
||||
uint32_t family_index = device->get_queue_info().family_indices[device->get_physical_queue_type(type)];
|
||||
@@ -580,43 +579,94 @@ void CommandBuffer::acquire_image_barrier(
|
||||
};
|
||||
b.oldLayout = old_layout;
|
||||
b.newLayout = new_layout;
|
||||
b.srcQueueFamilyIndex = src_queue_family;
|
||||
b.dstQueueFamilyIndex = deduce_acquire_release_family_index(*device, image, family_index);
|
||||
|
||||
b.dstStageMask = dst_stage;
|
||||
b.dstAccessMask = dst_access;
|
||||
b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL;
|
||||
b.dstQueueFamilyIndex = deduce_acquire_release_family_index(*device, image, family_index);
|
||||
b.srcStageMask = dst_stage;
|
||||
b.dstStageMask = dst_stage;
|
||||
image_barriers(1, &b);
|
||||
}
|
||||
|
||||
void CommandBuffer::release_external_buffer_barrier(
|
||||
const Buffer &buffer,
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access)
|
||||
{
|
||||
VkBufferMemoryBarrier2 b = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
|
||||
b.buffer = buffer.get_buffer();
|
||||
b.size = buffer.get_create_info().size;
|
||||
b.srcAccessMask = src_access;
|
||||
b.srcQueueFamilyIndex = deduce_acquire_release_family_index(*device);
|
||||
b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL;
|
||||
b.srcStageMask = src_stage;
|
||||
b.dstStageMask = VK_PIPELINE_STAGE_NONE;
|
||||
buffer_barriers(1, &b);
|
||||
}
|
||||
|
||||
void CommandBuffer::acquire_external_buffer_barrier(
|
||||
const Buffer &buffer,
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access)
|
||||
{
|
||||
VkBufferMemoryBarrier2 b = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
|
||||
b.buffer = buffer.get_buffer();
|
||||
b.size = buffer.get_create_info().size;
|
||||
b.dstAccessMask = dst_access;
|
||||
b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL;
|
||||
b.dstQueueFamilyIndex = deduce_acquire_release_family_index(*device);
|
||||
b.srcStageMask = dst_stage;
|
||||
b.dstStageMask = dst_stage;
|
||||
buffer_barriers(1, &b);
|
||||
}
|
||||
|
||||
void CommandBuffer::image_barrier_acquire(const Vulkan::Image &image,
|
||||
VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 src_stage, uint32_t src_queue_family,
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access)
|
||||
{
|
||||
VK_ASSERT(!actual_render_pass);
|
||||
VK_ASSERT(!framebuffer);
|
||||
VK_ASSERT(image.get_create_info().domain != ImageDomain::Transient);
|
||||
|
||||
VkImageMemoryBarrier2 b = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
|
||||
b.srcAccessMask = 0;
|
||||
b.dstAccessMask = dst_access;
|
||||
b.oldLayout = old_layout;
|
||||
b.newLayout = new_layout;
|
||||
b.image = image.get_image();
|
||||
b.subresourceRange.aspectMask = format_to_aspect_mask(image.get_create_info().format);
|
||||
b.subresourceRange.levelCount = image.get_create_info().levels;
|
||||
b.subresourceRange.layerCount = image.get_create_info().layers;
|
||||
b.srcQueueFamilyIndex = src_queue_family;
|
||||
b.dstQueueFamilyIndex = device->get_queue_info().family_indices[device->get_physical_queue_type(type)];
|
||||
b.srcStageMask = src_stage;
|
||||
b.dstStageMask = dst_stage;
|
||||
|
||||
image_barriers(1, &b);
|
||||
}
|
||||
|
||||
void CommandBuffer::release_buffer_barrier(
|
||||
const Buffer &buffer,
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access,
|
||||
uint32_t dst_queue_family)
|
||||
void CommandBuffer::image_barrier_release(const Vulkan::Image &image,
|
||||
VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access,
|
||||
uint32_t dst_queue_family)
|
||||
{
|
||||
VkBufferMemoryBarrier2 b = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
|
||||
b.buffer = buffer.get_buffer();
|
||||
b.size = buffer.get_create_info().size;
|
||||
b.srcQueueFamilyIndex = deduce_acquire_release_family_index(*device);
|
||||
VK_ASSERT(!actual_render_pass);
|
||||
VK_ASSERT(!framebuffer);
|
||||
VK_ASSERT(image.get_create_info().domain != ImageDomain::Transient);
|
||||
|
||||
VkImageMemoryBarrier2 b = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 };
|
||||
b.srcAccessMask = src_access;
|
||||
b.dstAccessMask = 0;
|
||||
b.oldLayout = old_layout;
|
||||
b.newLayout = new_layout;
|
||||
b.image = image.get_image();
|
||||
b.subresourceRange.aspectMask = format_to_aspect_mask(image.get_create_info().format);
|
||||
b.subresourceRange.levelCount = image.get_create_info().levels;
|
||||
b.subresourceRange.layerCount = image.get_create_info().layers;
|
||||
b.srcQueueFamilyIndex = device->get_queue_info().family_indices[device->get_physical_queue_type(type)];
|
||||
b.dstQueueFamilyIndex = dst_queue_family;
|
||||
b.srcStageMask = src_stage;
|
||||
b.srcAccessMask = src_access;
|
||||
buffer_barriers(1, &b);
|
||||
}
|
||||
b.dstStageMask = 0;
|
||||
|
||||
void CommandBuffer::acquire_buffer_barrier(
|
||||
const Buffer &buffer,
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access,
|
||||
uint32_t src_queue_family)
|
||||
{
|
||||
VkBufferMemoryBarrier2 b = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 };
|
||||
b.buffer = buffer.get_buffer();
|
||||
b.size = buffer.get_create_info().size;
|
||||
b.srcQueueFamilyIndex = src_queue_family;
|
||||
b.dstQueueFamilyIndex = deduce_acquire_release_family_index(*device);
|
||||
b.dstStageMask = dst_stage;
|
||||
b.dstAccessMask = dst_access;
|
||||
buffer_barriers(1, &b);
|
||||
image_barriers(1, &b);
|
||||
}
|
||||
|
||||
void CommandBuffer::image_barrier(const Image &image,
|
||||
@@ -1078,7 +1128,7 @@ Pipeline CommandBuffer::build_compute_pipeline(Device *device, const DeferredPip
|
||||
// we must assume compilation can be synchronous.
|
||||
if (mode == CompileMode::FailOnCompileRequired &&
|
||||
(device->get_workarounds().broken_pipeline_cache_control ||
|
||||
!device->get_device_features().vk13_features.pipelineCreationCacheControl))
|
||||
!device->get_device_features().pipeline_creation_cache_control_features.pipelineCreationCacheControl))
|
||||
{
|
||||
return {};
|
||||
}
|
||||
@@ -1116,7 +1166,7 @@ Pipeline CommandBuffer::build_compute_pipeline(Device *device, const DeferredPip
|
||||
spec_info.dataSize = spec_info.mapEntryCount * sizeof(uint32_t);
|
||||
}
|
||||
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo subgroup_size_info;
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT subgroup_size_info;
|
||||
|
||||
if (compile.static_state.state.subgroup_control_size)
|
||||
{
|
||||
@@ -1139,7 +1189,7 @@ Pipeline CommandBuffer::build_compute_pipeline(Device *device, const DeferredPip
|
||||
auto &table = device->get_device_table();
|
||||
|
||||
if (mode == CompileMode::FailOnCompileRequired)
|
||||
info.flags |= VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
|
||||
info.flags |= VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT;
|
||||
|
||||
auto start_ts = Util::get_current_time_nsecs();
|
||||
VkResult vr = table.vkCreateComputePipelines(device->get_device(), compile.cache, 1, &info, nullptr, &compute_pipeline);
|
||||
@@ -1177,7 +1227,7 @@ void CommandBuffer::extract_pipeline_state(DeferredPipelineCompile &compile) con
|
||||
|
||||
bool CommandBuffer::setup_subgroup_size_control(
|
||||
Vulkan::Device &device, VkPipelineShaderStageCreateInfo &stage_info,
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo &required_info,
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &required_info,
|
||||
VkShaderStageFlagBits stage, bool full_group,
|
||||
unsigned min_size_log2, unsigned max_size_log2)
|
||||
{
|
||||
@@ -1187,22 +1237,22 @@ bool CommandBuffer::setup_subgroup_size_control(
|
||||
auto &features = device.get_device_features();
|
||||
|
||||
if (full_group)
|
||||
stage_info.flags |= VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT;
|
||||
stage_info.flags |= VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT;
|
||||
|
||||
uint32_t min_subgroups = 1u << min_size_log2;
|
||||
uint32_t max_subgroups = 1u << max_size_log2;
|
||||
if (min_subgroups <= features.vk13_props.minSubgroupSize &&
|
||||
max_subgroups >= features.vk13_props.maxSubgroupSize)
|
||||
if (min_subgroups <= features.subgroup_size_control_properties.minSubgroupSize &&
|
||||
max_subgroups >= features.subgroup_size_control_properties.maxSubgroupSize)
|
||||
{
|
||||
stage_info.flags |= VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT;
|
||||
stage_info.flags |= VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT;
|
||||
}
|
||||
else
|
||||
{
|
||||
required_info = { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO };
|
||||
required_info = { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT };
|
||||
|
||||
// Pick a fixed subgroup size. Prefer smallest subgroup size.
|
||||
if (min_subgroups < features.vk13_props.minSubgroupSize)
|
||||
required_info.requiredSubgroupSize = features.vk13_props.minSubgroupSize;
|
||||
if (min_subgroups < features.subgroup_size_control_properties.minSubgroupSize)
|
||||
required_info.requiredSubgroupSize = features.subgroup_size_control_properties.minSubgroupSize;
|
||||
else
|
||||
required_info.requiredSubgroupSize = min_subgroups;
|
||||
|
||||
@@ -1223,7 +1273,7 @@ Pipeline CommandBuffer::build_graphics_pipeline(Device *device, const DeferredPi
|
||||
// we must assume compilation can be synchronous.
|
||||
if (mode == CompileMode::FailOnCompileRequired &&
|
||||
(device->get_workarounds().broken_pipeline_cache_control ||
|
||||
!device->get_device_features().vk13_features.pipelineCreationCacheControl))
|
||||
!device->get_device_features().pipeline_creation_cache_control_features.pipelineCreationCacheControl))
|
||||
{
|
||||
return {};
|
||||
}
|
||||
@@ -1388,8 +1438,8 @@ Pipeline CommandBuffer::build_graphics_pipeline(Device *device, const DeferredPi
|
||||
VkSpecializationMapEntry spec_entries[ecast(ShaderStage::Count)][VULKAN_NUM_TOTAL_SPEC_CONSTANTS];
|
||||
uint32_t spec_constants[Util::ecast(ShaderStage::Count)][VULKAN_NUM_TOTAL_SPEC_CONSTANTS];
|
||||
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo subgroup_size_info_task;
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo subgroup_size_info_mesh;
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT subgroup_size_info_task;
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT subgroup_size_info_mesh;
|
||||
|
||||
for (unsigned i = 0; i < Util::ecast(ShaderStage::Count); i++)
|
||||
{
|
||||
@@ -1429,7 +1479,7 @@ Pipeline CommandBuffer::build_graphics_pipeline(Device *device, const DeferredPi
|
||||
|
||||
if (stage == ShaderStage::Mesh || stage == ShaderStage::Task)
|
||||
{
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *required_info;
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *required_info;
|
||||
unsigned min_size_log2, max_size_log2;
|
||||
bool size_enabled, full_group;
|
||||
|
||||
@@ -1539,7 +1589,7 @@ Pipeline CommandBuffer::build_graphics_pipeline(Device *device, const DeferredPi
|
||||
auto &table = device->get_device_table();
|
||||
|
||||
if (mode == CompileMode::FailOnCompileRequired)
|
||||
pipe.flags |= VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
|
||||
pipe.flags |= VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT;
|
||||
|
||||
auto start_ts = Util::get_current_time_nsecs();
|
||||
VkResult res = table.vkCreateGraphicsPipelines(device->get_device(), compile.cache, 1, &pipe, nullptr, &pipeline);
|
||||
@@ -1878,9 +1928,9 @@ void CommandBuffer::wait_events(uint32_t count, const PipelineEvent *events, con
|
||||
for (uint32_t i = 0; i < count; i++)
|
||||
barrier(deps[i]);
|
||||
}
|
||||
else if (device->get_device_features().vk13_features.synchronization2)
|
||||
else if (device->get_device_features().sync2_features.synchronization2)
|
||||
{
|
||||
table.vkCmdWaitEvents2(cmd, count, vk_events.data(), deps);
|
||||
table.vkCmdWaitEvents2KHR(cmd, count, vk_events.data(), deps);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1903,9 +1953,9 @@ PipelineEvent CommandBuffer::signal_event(const VkDependencyInfo &dep)
|
||||
|
||||
if (!device->get_workarounds().emulate_event_as_pipeline_barrier)
|
||||
{
|
||||
if (device->get_device_features().vk13_features.synchronization2)
|
||||
if (device->get_device_features().sync2_features.synchronization2)
|
||||
{
|
||||
table.vkCmdSetEvent2(cmd, event->get_event(), &dep);
|
||||
table.vkCmdSetEvent2KHR(cmd, event->get_event(), &dep);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -2131,7 +2181,7 @@ void *CommandBuffer::allocate_constant_data(unsigned set, unsigned binding, VkDe
|
||||
device->request_uniform_block(ubo_block, size);
|
||||
data = ubo_block.allocate(size);
|
||||
}
|
||||
set_uniform_buffer(set, binding, *data.buffer, data.offset, data.padded_size);
|
||||
set_uniform_buffer(set, binding, *ubo_block.gpu, data.offset, data.padded_size);
|
||||
return data.host;
|
||||
}
|
||||
|
||||
@@ -2143,14 +2193,14 @@ void *CommandBuffer::allocate_index_data(VkDeviceSize size, VkIndexType index_ty
|
||||
device->request_index_block(ibo_block, size);
|
||||
data = ibo_block.allocate(size);
|
||||
}
|
||||
set_index_buffer(*data.buffer, data.offset, index_type);
|
||||
set_index_buffer(*ibo_block.gpu, data.offset, index_type);
|
||||
return data.host;
|
||||
}
|
||||
|
||||
BufferBlockAllocation CommandBuffer::request_scratch_buffer_memory(VkDeviceSize size)
|
||||
void *CommandBuffer::update_buffer(const Buffer &buffer, VkDeviceSize offset, VkDeviceSize size)
|
||||
{
|
||||
if (size == 0)
|
||||
return {};
|
||||
return nullptr;
|
||||
|
||||
auto data = staging_block.allocate(size);
|
||||
if (!data.host)
|
||||
@@ -2158,15 +2208,7 @@ BufferBlockAllocation CommandBuffer::request_scratch_buffer_memory(VkDeviceSize
|
||||
device->request_staging_block(staging_block, size);
|
||||
data = staging_block.allocate(size);
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
void *CommandBuffer::update_buffer(const Buffer &buffer, VkDeviceSize offset, VkDeviceSize size)
|
||||
{
|
||||
auto data = request_scratch_buffer_memory(size);
|
||||
if (data.host)
|
||||
copy_buffer(buffer, offset, *data.buffer, data.offset, size);
|
||||
copy_buffer(buffer, offset, *staging_block.cpu, data.offset, size);
|
||||
return data.host;
|
||||
}
|
||||
|
||||
@@ -2179,19 +2221,19 @@ void *CommandBuffer::update_image(const Image &image, const VkOffset3D &offset,
|
||||
uint32_t height = image.get_height(subresource.mipLevel);
|
||||
uint32_t depth = image.get_depth(subresource.mipLevel);
|
||||
|
||||
if ((subresource.aspectMask & (VK_IMAGE_ASPECT_PLANE_0_BIT |
|
||||
VK_IMAGE_ASPECT_PLANE_1_BIT |
|
||||
VK_IMAGE_ASPECT_PLANE_2_BIT)) != 0)
|
||||
{
|
||||
format_ycbcr_downsample_dimensions(create_info.format, subresource.aspectMask, width, height);
|
||||
}
|
||||
|
||||
if (!row_length)
|
||||
row_length = width;
|
||||
|
||||
if (!image_height)
|
||||
image_height = height;
|
||||
|
||||
if ((subresource.aspectMask & (VK_IMAGE_ASPECT_PLANE_0_BIT |
|
||||
VK_IMAGE_ASPECT_PLANE_1_BIT |
|
||||
VK_IMAGE_ASPECT_PLANE_2_BIT)) != 0)
|
||||
{
|
||||
format_ycbcr_downsample_dimensions(create_info.format, subresource.aspectMask, row_length, image_height);
|
||||
}
|
||||
|
||||
uint32_t blocks_x = row_length;
|
||||
uint32_t blocks_y = image_height;
|
||||
format_num_blocks(create_info.format, blocks_x, blocks_y);
|
||||
@@ -2206,7 +2248,7 @@ void *CommandBuffer::update_image(const Image &image, const VkOffset3D &offset,
|
||||
data = staging_block.allocate(size);
|
||||
}
|
||||
|
||||
copy_buffer_to_image(image, *data.buffer, data.offset, offset, extent, row_length, image_height, subresource);
|
||||
copy_buffer_to_image(image, *staging_block.cpu, data.offset, offset, extent, row_length, image_height, subresource);
|
||||
return data.host;
|
||||
}
|
||||
|
||||
@@ -2229,7 +2271,7 @@ void *CommandBuffer::allocate_vertex_data(unsigned binding, VkDeviceSize size, V
|
||||
data = vbo_block.allocate(size);
|
||||
}
|
||||
|
||||
set_vertex_binding(binding, *data.buffer, data.offset, stride, step_rate);
|
||||
set_vertex_binding(binding, *vbo_block.gpu, data.offset, stride, step_rate);
|
||||
return data.host;
|
||||
}
|
||||
|
||||
@@ -2733,7 +2775,7 @@ void CommandBuffer::draw_multi_indirect(const Buffer &buffer, VkDeviceSize offse
|
||||
const Buffer &count, VkDeviceSize count_offset)
|
||||
{
|
||||
VK_ASSERT(!is_compute);
|
||||
if (!get_device().get_device_features().vk12_features.drawIndirectCount)
|
||||
if (!get_device().get_device_features().supports_draw_indirect_count)
|
||||
{
|
||||
LOGE("VK_KHR_draw_indirect_count not supported, dropping draw call.\n");
|
||||
return;
|
||||
@@ -2742,9 +2784,9 @@ void CommandBuffer::draw_multi_indirect(const Buffer &buffer, VkDeviceSize offse
|
||||
if (flush_render_state(true) != VK_NULL_HANDLE)
|
||||
{
|
||||
VK_ASSERT(pipeline_state.program->get_shader(ShaderStage::Vertex) != nullptr);
|
||||
table.vkCmdDrawIndirectCount(cmd, buffer.get_buffer(), offset,
|
||||
count.get_buffer(), count_offset,
|
||||
draw_count, stride);
|
||||
table.vkCmdDrawIndirectCountKHR(cmd, buffer.get_buffer(), offset,
|
||||
count.get_buffer(), count_offset,
|
||||
draw_count, stride);
|
||||
}
|
||||
else
|
||||
LOGE("Failed to flush render state, draw call will be dropped.\n");
|
||||
@@ -2754,7 +2796,7 @@ void CommandBuffer::draw_indexed_multi_indirect(const Buffer &buffer, VkDeviceSi
|
||||
const Buffer &count, VkDeviceSize count_offset)
|
||||
{
|
||||
VK_ASSERT(!is_compute);
|
||||
if (!get_device().get_device_features().vk12_features.drawIndirectCount)
|
||||
if (!get_device().get_device_features().supports_draw_indirect_count)
|
||||
{
|
||||
LOGE("VK_KHR_draw_indirect_count not supported, dropping draw call.\n");
|
||||
return;
|
||||
@@ -2763,9 +2805,9 @@ void CommandBuffer::draw_indexed_multi_indirect(const Buffer &buffer, VkDeviceSi
|
||||
if (flush_render_state(true) != VK_NULL_HANDLE)
|
||||
{
|
||||
VK_ASSERT(pipeline_state.program->get_shader(ShaderStage::Vertex) != nullptr);
|
||||
table.vkCmdDrawIndexedIndirectCount(cmd, buffer.get_buffer(), offset,
|
||||
count.get_buffer(), count_offset,
|
||||
draw_count, stride);
|
||||
table.vkCmdDrawIndexedIndirectCountKHR(cmd, buffer.get_buffer(), offset,
|
||||
count.get_buffer(), count_offset,
|
||||
draw_count, stride);
|
||||
}
|
||||
else
|
||||
LOGE("Failed to flush render state, draw call will be dropped.\n");
|
||||
@@ -2800,26 +2842,13 @@ void CommandBuffer::execute_indirect_commands(
|
||||
const Vulkan::Buffer &indirect, VkDeviceSize offset,
|
||||
const Vulkan::Buffer *count, size_t count_offset)
|
||||
{
|
||||
VK_ASSERT((is_compute && indirect_layout->get_bind_point() == VK_PIPELINE_BIND_POINT_COMPUTE) ||
|
||||
(!is_compute && indirect_layout->get_bind_point() == VK_PIPELINE_BIND_POINT_GRAPHICS));
|
||||
VK_ASSERT(!is_compute);
|
||||
VK_ASSERT(device->get_device_features().device_generated_commands_features.deviceGeneratedCommands);
|
||||
VK_ASSERT(!is_compute || device->get_device_features().device_generated_commands_compute_features.deviceGeneratedCompute);
|
||||
|
||||
if (is_compute)
|
||||
if (flush_render_state(true) == VK_NULL_HANDLE)
|
||||
{
|
||||
if (flush_compute_state(true) == VK_NULL_HANDLE)
|
||||
{
|
||||
LOGE("Failed to flush compute state, dispatch will be dropped.\n");
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (flush_render_state(true) == VK_NULL_HANDLE)
|
||||
{
|
||||
LOGE("Failed to flush render state, draw call will be dropped.\n");
|
||||
return;
|
||||
}
|
||||
LOGE("Failed to flush render state, draw call will be dropped.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO: Linearly allocate these, but big indirect commands like these
|
||||
@@ -2829,7 +2858,7 @@ void CommandBuffer::execute_indirect_commands(
|
||||
VkMemoryRequirements2 reqs = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 };
|
||||
|
||||
generated.pipeline = current_pipeline.pipeline;
|
||||
generated.pipelineBindPoint = indirect_layout->get_bind_point();
|
||||
generated.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||||
generated.indirectCommandsLayout = indirect_layout->get_layout();
|
||||
generated.maxSequencesCount = sequences;
|
||||
|
||||
@@ -2848,7 +2877,7 @@ void CommandBuffer::execute_indirect_commands(
|
||||
|
||||
VkGeneratedCommandsInfoNV exec_info = { VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV };
|
||||
exec_info.indirectCommandsLayout = indirect_layout->get_layout();
|
||||
exec_info.pipelineBindPoint = indirect_layout->get_bind_point();
|
||||
exec_info.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||||
exec_info.streamCount = 1;
|
||||
exec_info.pStreams = &stream;
|
||||
exec_info.preprocessSize = reqs.memoryRequirements.size;
|
||||
@@ -3076,62 +3105,45 @@ void CommandBuffer::end()
|
||||
{
|
||||
end_threaded_recording();
|
||||
|
||||
if (vbo_block.is_mapped())
|
||||
if (vbo_block.mapped)
|
||||
device->request_vertex_block_nolock(vbo_block, 0);
|
||||
if (ibo_block.is_mapped())
|
||||
if (ibo_block.mapped)
|
||||
device->request_index_block_nolock(ibo_block, 0);
|
||||
if (ubo_block.is_mapped())
|
||||
if (ubo_block.mapped)
|
||||
device->request_uniform_block_nolock(ubo_block, 0);
|
||||
if (staging_block.is_mapped())
|
||||
if (staging_block.mapped)
|
||||
device->request_staging_block_nolock(staging_block, 0);
|
||||
}
|
||||
|
||||
void CommandBuffer::insert_label(const char *name, const float *color)
|
||||
{
|
||||
if (!device->ext.supports_debug_utils || !vkCmdInsertDebugUtilsLabelEXT)
|
||||
return;
|
||||
|
||||
VkDebugUtilsLabelEXT info = { VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT };
|
||||
if (color)
|
||||
{
|
||||
for (unsigned i = 0; i < 4; i++)
|
||||
info.color[i] = color[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
for (unsigned i = 0; i < 4; i++)
|
||||
info.color[i] = 1.0f;
|
||||
}
|
||||
|
||||
info.pLabelName = name;
|
||||
vkCmdInsertDebugUtilsLabelEXT(cmd, &info);
|
||||
}
|
||||
|
||||
void CommandBuffer::begin_region(const char *name, const float *color)
|
||||
{
|
||||
if (!device->ext.supports_debug_utils || !vkCmdBeginDebugUtilsLabelEXT)
|
||||
return;
|
||||
|
||||
VkDebugUtilsLabelEXT info = { VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT };
|
||||
if (color)
|
||||
if (device->ext.supports_debug_utils)
|
||||
{
|
||||
for (unsigned i = 0; i < 4; i++)
|
||||
info.color[i] = color[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
for (unsigned i = 0; i < 4; i++)
|
||||
info.color[i] = 1.0f;
|
||||
}
|
||||
VkDebugUtilsLabelEXT info = { VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT };
|
||||
if (color)
|
||||
{
|
||||
for (unsigned i = 0; i < 4; i++)
|
||||
info.color[i] = color[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
for (unsigned i = 0; i < 4; i++)
|
||||
info.color[i] = 1.0f;
|
||||
}
|
||||
|
||||
info.pLabelName = name;
|
||||
vkCmdBeginDebugUtilsLabelEXT(cmd, &info);
|
||||
info.pLabelName = name;
|
||||
if (vkCmdBeginDebugUtilsLabelEXT)
|
||||
vkCmdBeginDebugUtilsLabelEXT(cmd, &info);
|
||||
}
|
||||
}
|
||||
|
||||
void CommandBuffer::end_region()
|
||||
{
|
||||
if (device->ext.supports_debug_utils && vkCmdEndDebugUtilsLabelEXT)
|
||||
vkCmdEndDebugUtilsLabelEXT(cmd);
|
||||
if (device->ext.supports_debug_utils)
|
||||
{
|
||||
if (vkCmdEndDebugUtilsLabelEXT)
|
||||
vkCmdEndDebugUtilsLabelEXT(cmd);
|
||||
}
|
||||
}
|
||||
|
||||
void CommandBuffer::enable_profiling()
|
||||
|
||||
@@ -290,7 +290,10 @@ public:
|
||||
AsyncCompute = QUEUE_INDEX_COMPUTE,
|
||||
AsyncTransfer = QUEUE_INDEX_TRANSFER,
|
||||
VideoDecode = QUEUE_INDEX_VIDEO_DECODE,
|
||||
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
||||
VideoEncode = QUEUE_INDEX_VIDEO_ENCODE,
|
||||
#endif
|
||||
AsyncGraphics = QUEUE_INDEX_COUNT, // Aliases with either Generic or AsyncCompute queue
|
||||
Count
|
||||
};
|
||||
|
||||
@@ -301,7 +304,6 @@ public:
|
||||
}
|
||||
|
||||
void begin_region(const char *name, const float *color = nullptr);
|
||||
void insert_label(const char *name, const float *color = nullptr);
|
||||
void end_region();
|
||||
|
||||
Device &get_device()
|
||||
@@ -391,20 +393,26 @@ public:
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access,
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access);
|
||||
|
||||
void image_barrier_acquire(const Image &image,
|
||||
VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 src_stage, uint32_t src_queue_family,
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access);
|
||||
|
||||
void image_barrier_release(const Image &image,
|
||||
VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access,
|
||||
uint32_t dst_queue_family);
|
||||
|
||||
void buffer_barriers(uint32_t buffer_barriers, const VkBufferMemoryBarrier2 *buffers);
|
||||
void image_barriers(uint32_t image_barriers, const VkImageMemoryBarrier2 *images);
|
||||
|
||||
void release_buffer_barrier(const Buffer &buffer, VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access,
|
||||
uint32_t dst_queue_family = VK_QUEUE_FAMILY_EXTERNAL);
|
||||
void acquire_buffer_barrier(const Buffer &buffer, VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access,
|
||||
uint32_t src_queue_family = VK_QUEUE_FAMILY_EXTERNAL);
|
||||
void release_image_barrier(const Image &image,
|
||||
VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access,
|
||||
uint32_t dst_queue_family = VK_QUEUE_FAMILY_EXTERNAL);
|
||||
void acquire_image_barrier(const Image &image, VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access,
|
||||
uint32_t src_queue_family = VK_QUEUE_FAMILY_EXTERNAL);
|
||||
void release_external_buffer_barrier(const Buffer &buffer, VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access);
|
||||
void acquire_external_buffer_barrier(const Buffer &buffer, VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access);
|
||||
void release_external_image_barrier(const Image &image,
|
||||
VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 src_stage, VkAccessFlags2 src_access);
|
||||
void acquire_external_image_barrier(const Image &image, VkImageLayout old_layout, VkImageLayout new_layout,
|
||||
VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst_access);
|
||||
|
||||
void blit_image(const Image &dst,
|
||||
const Image &src,
|
||||
@@ -488,7 +496,6 @@ public:
|
||||
void *update_image(const Image &image, const VkOffset3D &offset, const VkExtent3D &extent, uint32_t row_length,
|
||||
uint32_t image_height, const VkImageSubresourceLayers &subresource);
|
||||
void *update_image(const Image &image, uint32_t row_length = 0, uint32_t image_height = 0);
|
||||
BufferBlockAllocation request_scratch_buffer_memory(VkDeviceSize size);
|
||||
|
||||
void set_viewport(const VkViewport &viewport);
|
||||
const VkViewport &get_viewport() const;
|
||||
|
||||
+386
-331
File diff suppressed because it is too large.
Load diff
+45
-35
@@ -49,84 +49,93 @@ namespace Vulkan
|
||||
struct DeviceFeatures
|
||||
{
|
||||
bool supports_debug_utils = false;
|
||||
bool supports_mirror_clamp_to_edge = false;
|
||||
bool supports_external_memory_host = false;
|
||||
bool supports_surface_capabilities2 = false;
|
||||
bool supports_full_screen_exclusive = false;
|
||||
bool supports_descriptor_indexing = false;
|
||||
bool supports_conservative_rasterization = false;
|
||||
bool supports_draw_indirect_count = false;
|
||||
bool supports_driver_properties = false;
|
||||
bool supports_calibrated_timestamps = false;
|
||||
bool supports_memory_budget = false;
|
||||
bool supports_astc_decode_mode = false;
|
||||
bool supports_sync2 = false;
|
||||
bool supports_create_renderpass2 = false;
|
||||
bool supports_video_queue = false;
|
||||
bool supports_driver_properties = false;
|
||||
bool supports_video_decode_queue = false;
|
||||
bool supports_video_decode_h264 = false;
|
||||
bool supports_video_decode_h265 = false;
|
||||
bool supports_astc_decode_mode = false;
|
||||
bool supports_image_format_list = false;
|
||||
bool supports_format_feature_flags2 = false;
|
||||
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
||||
bool supports_video_encode_queue = false;
|
||||
bool supports_video_encode_h264 = false;
|
||||
bool supports_video_encode_h265 = false;
|
||||
#endif
|
||||
bool supports_pipeline_creation_cache_control = false;
|
||||
bool supports_format_feature_flags2 = false;
|
||||
bool supports_external = false;
|
||||
bool supports_image_format_list = false;
|
||||
bool supports_shader_float_control = false;
|
||||
bool supports_tooling_info = false;
|
||||
bool supports_hdr_metadata = false;
|
||||
bool supports_swapchain_colorspace = false;
|
||||
bool supports_surface_maintenance1 = false;
|
||||
bool supports_store_op_none = false;
|
||||
bool supports_push_descriptor = false;
|
||||
bool supports_spirv_1_4 = false;
|
||||
|
||||
// Vulkan 1.1 core
|
||||
VkPhysicalDeviceFeatures enabled_features = {};
|
||||
|
||||
VkPhysicalDeviceVulkan11Features vk11_features = {};
|
||||
VkPhysicalDeviceVulkan12Features vk12_features = {};
|
||||
VkPhysicalDeviceVulkan13Features vk13_features = {};
|
||||
VkPhysicalDeviceVulkan11Properties vk11_props = {};
|
||||
VkPhysicalDeviceVulkan12Properties vk12_props = {};
|
||||
VkPhysicalDeviceVulkan13Properties vk13_props = {};
|
||||
VkPhysicalDeviceMultiviewFeatures multiview_features = {};
|
||||
VkPhysicalDeviceShaderDrawParametersFeatures shader_draw_parameters_features = {};
|
||||
VkPhysicalDeviceSamplerYcbcrConversionFeatures sampler_ycbcr_conversion_features = {};
|
||||
VkPhysicalDeviceMultiviewProperties multiview_properties = {};
|
||||
VkPhysicalDeviceSubgroupProperties subgroup_properties = {};
|
||||
|
||||
// KHR
|
||||
VkPhysicalDeviceTimelineSemaphoreFeaturesKHR timeline_semaphore_features = {};
|
||||
VkPhysicalDevicePerformanceQueryFeaturesKHR performance_query_features = {};
|
||||
VkPhysicalDeviceDriverPropertiesKHR driver_properties = {};
|
||||
VkPhysicalDeviceSynchronization2FeaturesKHR sync2_features = {};
|
||||
VkPhysicalDevicePresentIdFeaturesKHR present_id_features = {};
|
||||
VkPhysicalDevicePresentWaitFeaturesKHR present_wait_features = {};
|
||||
VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR barycentric_features = {};
|
||||
VkPhysicalDeviceVideoMaintenance1FeaturesKHR video_maintenance1_features = {};
|
||||
VkPhysicalDevice8BitStorageFeaturesKHR storage_8bit_features = {};
|
||||
VkPhysicalDevice16BitStorageFeaturesKHR storage_16bit_features = {};
|
||||
VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8_features = {};
|
||||
VkPhysicalDeviceFloatControlsPropertiesKHR float_control_properties = {};
|
||||
VkPhysicalDeviceBufferDeviceAddressFeaturesKHR buffer_device_address_features = {};
|
||||
VkPhysicalDeviceIDProperties id_properties = {};
|
||||
VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR shader_subgroup_extended_types_features = {};
|
||||
|
||||
// EXT
|
||||
VkPhysicalDeviceExternalMemoryHostPropertiesEXT host_memory_properties = {};
|
||||
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT subgroup_size_control_features = {};
|
||||
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT subgroup_size_control_properties = {};
|
||||
VkPhysicalDeviceHostQueryResetFeaturesEXT host_query_reset_features = {};
|
||||
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT demote_to_helper_invocation_features = {};
|
||||
VkPhysicalDeviceScalarBlockLayoutFeaturesEXT scalar_block_features = {};
|
||||
VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ubo_std430_features = {};
|
||||
VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptor_indexing_features = {};
|
||||
VkPhysicalDeviceDescriptorIndexingPropertiesEXT descriptor_indexing_properties = {};
|
||||
VkPhysicalDeviceConservativeRasterizationPropertiesEXT conservative_rasterization_properties = {};
|
||||
VkPhysicalDeviceMemoryPriorityFeaturesEXT memory_priority_features = {};
|
||||
VkPhysicalDeviceASTCDecodeFeaturesEXT astc_decode_features = {};
|
||||
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT astc_hdr_features = {};
|
||||
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT pipeline_creation_cache_control_features = {};
|
||||
VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT swapchain_maintenance1_features = {};
|
||||
VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT pageable_device_local_memory_features = {};
|
||||
VkPhysicalDeviceMeshShaderFeaturesEXT mesh_shader_features = {};
|
||||
VkPhysicalDeviceMeshShaderPropertiesEXT mesh_shader_properties = {};
|
||||
VkPhysicalDeviceIndexTypeUint8FeaturesEXT index_type_uint8_features = {};
|
||||
|
||||
// Vendor
|
||||
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV compute_shader_derivative_features = {};
|
||||
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV device_generated_commands_features = {};
|
||||
VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV device_generated_commands_compute_features = {};
|
||||
VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV device_generated_commands_properties = {};
|
||||
|
||||
// Fallback feature structs (Vulkan 1.1)
|
||||
VkPhysicalDeviceHostQueryResetFeatures host_query_reset_features = {};
|
||||
VkPhysicalDevice16BitStorageFeaturesKHR storage_16bit_features = {};
|
||||
// Fallback feature structs (Vulkan 1.2)
|
||||
VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8_features = {};
|
||||
VkPhysicalDevice8BitStorageFeaturesKHR storage_8bit_features = {};
|
||||
// Fallback feature structs (Vulkan 1.3)
|
||||
VkPhysicalDeviceSubgroupSizeControlFeatures subgroup_size_control_features = {};
|
||||
|
||||
VkDriverId driver_id = {};
|
||||
|
||||
// References Vulkan::Context.
|
||||
const VkPhysicalDeviceFeatures2 *pdf2 = nullptr;
|
||||
const char * const * instance_extensions = nullptr;
|
||||
uint32_t num_instance_extensions = 0;
|
||||
const char * const * device_extensions = nullptr;
|
||||
uint32_t num_device_extensions = 0;
|
||||
|
||||
uint32_t instance_api_core_version = VK_API_VERSION_1_1;
|
||||
uint32_t device_api_core_version = VK_API_VERSION_1_1;
|
||||
};
|
||||
|
||||
enum VendorID
|
||||
@@ -142,7 +151,9 @@ enum ContextCreationFlagBits
|
||||
{
|
||||
CONTEXT_CREATION_ENABLE_ADVANCED_WSI_BIT = 1 << 0,
|
||||
CONTEXT_CREATION_ENABLE_VIDEO_DECODE_BIT = 1 << 1,
|
||||
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
||||
CONTEXT_CREATION_ENABLE_VIDEO_ENCODE_BIT = 1 << 2,
|
||||
#endif
|
||||
CONTEXT_CREATION_ENABLE_VIDEO_H264_BIT = 1 << 3,
|
||||
CONTEXT_CREATION_ENABLE_VIDEO_H265_BIT = 1 << 4
|
||||
};
|
||||
@@ -347,6 +358,7 @@ private:
|
||||
VkPhysicalDevice gpu = VK_NULL_HANDLE;
|
||||
VolkDeviceTable device_table = {};
|
||||
SystemHandles handles;
|
||||
|
||||
VkPhysicalDeviceProperties gpu_props = {};
|
||||
VkPhysicalDeviceMemoryProperties mem_props = {};
|
||||
|
||||
@@ -376,8 +388,8 @@ private:
|
||||
#endif
|
||||
std::function<void (const char *)> message_callback;
|
||||
|
||||
void destroy_instance();
|
||||
void destroy_device();
|
||||
void destroy();
|
||||
void check_descriptor_indexing_features();
|
||||
|
||||
bool physical_device_supports_surface_and_profile(VkPhysicalDevice candidate_gpu, VkSurfaceKHR surface) const;
|
||||
|
||||
@@ -390,8 +402,6 @@ private:
|
||||
bool init_profile();
|
||||
VkResult create_instance_from_profile(const VkInstanceCreateInfo &info, VkInstance *pInstance);
|
||||
VkResult create_device_from_profile(const VkDeviceCreateInfo &info, VkDevice *pDevice);
|
||||
|
||||
VkApplicationInfo get_promoted_application_info() const;
|
||||
};
|
||||
|
||||
using ContextHandle = Util::IntrusivePtr<Context>;
|
||||
|
||||
@@ -45,7 +45,7 @@ DescriptorSetAllocator::DescriptorSetAllocator(Hash hash, Device *device_, const
|
||||
per_thread.emplace_back(new PerThread);
|
||||
}
|
||||
|
||||
if (bindless && !device->get_device_features().vk12_features.descriptorIndexing)
|
||||
if (bindless && !device->get_device_features().supports_descriptor_indexing)
|
||||
{
|
||||
LOGE("Cannot support descriptor indexing on this device.\n");
|
||||
return;
|
||||
@@ -369,53 +369,42 @@ bool BindlessDescriptorPool::allocate_descriptors(unsigned count)
|
||||
allocated_sets++;
|
||||
|
||||
desc_set = allocator->allocate_bindless_set(desc_pool, count);
|
||||
|
||||
infos.reserve(count);
|
||||
write_count = 0;
|
||||
|
||||
return desc_set != VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
void BindlessDescriptorPool::push_texture(const ImageView &view)
|
||||
void BindlessDescriptorPool::set_texture(unsigned binding, const ImageView &view)
|
||||
{
|
||||
// TODO: Deal with integer view for depth-stencil images?
|
||||
push_texture(view.get_float_view(), view.get_image().get_layout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL));
|
||||
set_texture(binding, view.get_float_view(), view.get_image().get_layout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL));
|
||||
}
|
||||
|
||||
void BindlessDescriptorPool::push_texture_unorm(const ImageView &view)
|
||||
void BindlessDescriptorPool::set_texture_unorm(unsigned binding, const ImageView &view)
|
||||
{
|
||||
push_texture(view.get_unorm_view(), view.get_image().get_layout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL));
|
||||
set_texture(binding, view.get_unorm_view(), view.get_image().get_layout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL));
|
||||
}
|
||||
|
||||
void BindlessDescriptorPool::push_texture_srgb(const ImageView &view)
|
||||
void BindlessDescriptorPool::set_texture_srgb(unsigned binding, const ImageView &view)
|
||||
{
|
||||
push_texture(view.get_srgb_view(), view.get_image().get_layout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL));
|
||||
set_texture(binding, view.get_srgb_view(), view.get_image().get_layout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL));
|
||||
}
|
||||
|
||||
void BindlessDescriptorPool::push_texture(VkImageView view, VkImageLayout layout)
|
||||
void BindlessDescriptorPool::set_texture(unsigned binding, VkImageView view, VkImageLayout layout)
|
||||
{
|
||||
VK_ASSERT(write_count < infos.get_capacity());
|
||||
auto &image_info = infos[write_count];
|
||||
image_info = { VK_NULL_HANDLE, view, layout };
|
||||
write_count++;
|
||||
}
|
||||
VkWriteDescriptorSet write = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET };
|
||||
write.descriptorCount = 1;
|
||||
write.dstArrayElement = binding;
|
||||
write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
|
||||
write.dstSet = desc_set;
|
||||
|
||||
void BindlessDescriptorPool::update()
|
||||
{
|
||||
VkWriteDescriptorSet desc = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET };
|
||||
desc.descriptorCount = write_count;
|
||||
desc.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
|
||||
desc.dstSet = desc_set;
|
||||
const VkDescriptorImageInfo info = {
|
||||
VK_NULL_HANDLE,
|
||||
view,
|
||||
layout,
|
||||
};
|
||||
write.pImageInfo = &info;
|
||||
|
||||
desc.pImageInfo = infos.data();
|
||||
desc.pBufferInfo = nullptr;
|
||||
desc.pTexelBufferView = nullptr;
|
||||
|
||||
if (write_count)
|
||||
{
|
||||
auto &table = device->get_device_table();
|
||||
table.vkUpdateDescriptorSets(device->get_device(), 1, &desc, 0, nullptr);
|
||||
}
|
||||
auto &table = device->get_device_table();
|
||||
table.vkUpdateDescriptorSets(device->get_device(), 1, &write, 0, nullptr);
|
||||
}
|
||||
|
||||
void BindlessDescriptorPoolDeleter::operator()(BindlessDescriptorPool *pool)
|
||||
@@ -489,8 +478,7 @@ VkDescriptorSet BindlessAllocator::commit(Device &device)
|
||||
}
|
||||
|
||||
for (size_t i = 0, n = views.size(); i < n; i++)
|
||||
descriptor_pool->push_texture(*views[i]);
|
||||
descriptor_pool->update();
|
||||
descriptor_pool->set_texture(i, *views[i]);
|
||||
return descriptor_pool->get_descriptor_set();
|
||||
}
|
||||
}
|
||||
@@ -28,7 +28,6 @@
|
||||
#include "vulkan_headers.hpp"
|
||||
#include "sampler.hpp"
|
||||
#include "limits.hpp"
|
||||
#include "dynamic_array.hpp"
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include "cookie.hpp"
|
||||
@@ -83,10 +82,9 @@ public:
|
||||
bool allocate_descriptors(unsigned count);
|
||||
VkDescriptorSet get_descriptor_set() const;
|
||||
|
||||
void push_texture(const ImageView &view);
|
||||
void push_texture_unorm(const ImageView &view);
|
||||
void push_texture_srgb(const ImageView &view);
|
||||
void update();
|
||||
void set_texture(unsigned binding, const ImageView &view);
|
||||
void set_texture_unorm(unsigned binding, const ImageView &view);
|
||||
void set_texture_srgb(unsigned binding, const ImageView &view);
|
||||
|
||||
private:
|
||||
Device *device;
|
||||
@@ -99,15 +97,14 @@ private:
|
||||
uint32_t allocated_descriptor_count = 0;
|
||||
uint32_t total_descriptors = 0;
|
||||
|
||||
void push_texture(VkImageView view, VkImageLayout layout);
|
||||
Util::DynamicArray<VkDescriptorImageInfo> infos;
|
||||
uint32_t write_count = 0;
|
||||
void set_texture(unsigned binding, VkImageView view, VkImageLayout layout);
|
||||
};
|
||||
using BindlessDescriptorPoolHandle = Util::IntrusivePtr<BindlessDescriptorPool>;
|
||||
|
||||
enum class BindlessResourceType
|
||||
{
|
||||
Image
|
||||
ImageFP,
|
||||
ImageInt
|
||||
};
|
||||
|
||||
class DescriptorSetAllocator : public HashedObject<DescriptorSetAllocator>
|
||||
@@ -183,7 +180,7 @@ private:
|
||||
BindlessDescriptorPoolHandle descriptor_pool;
|
||||
unsigned max_sets_per_pool = 0;
|
||||
unsigned max_descriptors_per_pool = 0;
|
||||
BindlessResourceType resource_type = BindlessResourceType::Image;
|
||||
BindlessResourceType resource_type = BindlessResourceType::ImageFP;
|
||||
std::vector<const ImageView *> views;
|
||||
};
|
||||
}
|
||||
+323
-163
File diff suppressed because it is too large.
Load diff
+16
-17
@@ -129,7 +129,7 @@ class BatchComposer
|
||||
public:
|
||||
enum { MaxSubmissions = 8 };
|
||||
|
||||
BatchComposer();
|
||||
explicit BatchComposer(bool split_binary_timeline_semaphores);
|
||||
void add_wait_submissions(WaitSemaphores &sem);
|
||||
void add_wait_semaphore(SemaphoreHolder &sem, VkPipelineStageFlags2 stage);
|
||||
void add_wait_semaphore(VkSemaphore sem, VkPipelineStageFlags2 stage);
|
||||
@@ -148,6 +148,10 @@ private:
|
||||
Util::SmallVector<VkCommandBufferSubmitInfo> cmds[MaxSubmissions];
|
||||
|
||||
unsigned submit_index = 0;
|
||||
bool split_binary_timeline_semaphores = false;
|
||||
|
||||
bool has_timeline_semaphore_in_batch(unsigned index) const;
|
||||
bool has_binary_semaphore_in_batch(unsigned index) const;
|
||||
};
|
||||
}
|
||||
|
||||
@@ -245,14 +249,6 @@ public:
|
||||
|
||||
// Frame-pushing interface.
|
||||
void next_frame_context();
|
||||
|
||||
// Normally, the main thread ensures forward progress of the frame context
|
||||
// so that async tasks don't have to care about it,
|
||||
// but in the case where async threads are continuously pumping Vulkan work
|
||||
// in the background, they need to reclaim memory if WSI goes to sleep for a long period of time.
|
||||
void next_frame_context_in_async_thread();
|
||||
void set_enable_async_thread_frame_context(bool enable);
|
||||
|
||||
void wait_idle();
|
||||
void end_frame_context();
|
||||
|
||||
@@ -479,11 +475,6 @@ public:
|
||||
return ext;
|
||||
}
|
||||
|
||||
bool consumes_debug_markers() const
|
||||
{
|
||||
return debug_marker_sensitive;
|
||||
}
|
||||
|
||||
bool swapchain_touched() const;
|
||||
|
||||
double convert_device_timestamp_delta(uint64_t start_ticks, uint64_t end_ticks) const;
|
||||
@@ -549,7 +540,6 @@ private:
|
||||
VkPhysicalDeviceProperties gpu_props;
|
||||
|
||||
DeviceFeatures ext;
|
||||
bool debug_marker_sensitive = false;
|
||||
void init_stock_samplers();
|
||||
void init_stock_sampler(StockSampler sampler, float max_aniso, float lod_bias);
|
||||
void init_timeline_semaphores();
|
||||
@@ -597,7 +587,6 @@ private:
|
||||
std::condition_variable cond;
|
||||
Util::RWSpinLock read_only_cache;
|
||||
unsigned counter = 0;
|
||||
bool async_frame_context = false;
|
||||
} lock;
|
||||
|
||||
struct PerFrame
|
||||
@@ -626,7 +615,8 @@ private:
|
||||
std::vector<BufferBlock> ubo_blocks;
|
||||
std::vector<BufferBlock> staging_blocks;
|
||||
|
||||
std::vector<VkFence> wait_and_recycle_fences;
|
||||
std::vector<VkFence> wait_fences;
|
||||
std::vector<VkFence> recycle_fences;
|
||||
|
||||
std::vector<DeviceAllocation> allocations;
|
||||
std::vector<VkFramebuffer> destroyed_framebuffers;
|
||||
@@ -696,6 +686,14 @@ private:
|
||||
uint64_t value;
|
||||
};
|
||||
|
||||
// Pending buffers which need to be copied from CPU to GPU before submitting graphics or compute work.
|
||||
struct
|
||||
{
|
||||
std::vector<BufferBlock> vbo;
|
||||
std::vector<BufferBlock> ibo;
|
||||
std::vector<BufferBlock> ubo;
|
||||
} dma;
|
||||
|
||||
void submit_queue(QueueIndices physical_type, InternalFence *fence,
|
||||
SemaphoreHolder *external_semaphore = nullptr,
|
||||
unsigned semaphore_count = 0,
|
||||
@@ -750,6 +748,7 @@ private:
|
||||
std::function<void ()> queue_lock_callback;
|
||||
std::function<void ()> queue_unlock_callback;
|
||||
void flush_frame(QueueIndices physical_type);
|
||||
void sync_buffer_blocks();
|
||||
void submit_empty_inner(QueueIndices type, InternalFence *fence,
|
||||
SemaphoreHolder *external_semaphore,
|
||||
unsigned semaphore_count,
|
||||
|
||||
@@ -120,8 +120,6 @@ void Device::register_shader_module(VkShaderModule module, Fossilize::Hash hash,
|
||||
return;
|
||||
}
|
||||
|
||||
replayer_state->feature_filter->register_shader_module_info(module, &info);
|
||||
|
||||
if (!recorder_state->recorder.record_shader_module(module, info, hash))
|
||||
LOGW("Failed to register shader module.\n");
|
||||
}
|
||||
@@ -258,26 +256,17 @@ bool Device::fossilize_replay_graphics_pipeline(Fossilize::Hash hash, VkGraphics
|
||||
reinterpret_cast<const ImmutableSamplerBank *>(info.layout));
|
||||
}
|
||||
|
||||
if (ret)
|
||||
{
|
||||
// The layout is dummy, resolve it here.
|
||||
info.layout = ret->get_pipeline_layout()->get_layout();
|
||||
// The layout is dummy, resolve it here.
|
||||
info.layout = ret->get_pipeline_layout()->get_layout();
|
||||
|
||||
// Resolve shader modules.
|
||||
if (vert_index >= 0)
|
||||
const_cast<VkPipelineShaderStageCreateInfo *>(info.pStages)[vert_index].module = vert_shader->get_module();
|
||||
if (task_index >= 0)
|
||||
const_cast<VkPipelineShaderStageCreateInfo *>(info.pStages)[task_index].module = task_shader->get_module();
|
||||
if (mesh_index >= 0)
|
||||
const_cast<VkPipelineShaderStageCreateInfo *>(info.pStages)[mesh_index].module = mesh_shader->get_module();
|
||||
const_cast<VkPipelineShaderStageCreateInfo *>(info.pStages)[frag_index].module = frag_shader->get_module();
|
||||
}
|
||||
|
||||
if (!ret || !replayer_state->feature_filter->graphics_pipeline_is_supported(&info))
|
||||
{
|
||||
replayer_state->progress.pipelines.fetch_add(1, std::memory_order_release);
|
||||
return true;
|
||||
}
|
||||
// Resolve shader modules.
|
||||
if (vert_index >= 0)
|
||||
const_cast<VkPipelineShaderStageCreateInfo *>(info.pStages)[vert_index].module = vert_shader->get_module();
|
||||
if (task_index >= 0)
|
||||
const_cast<VkPipelineShaderStageCreateInfo *>(info.pStages)[task_index].module = task_shader->get_module();
|
||||
if (mesh_index >= 0)
|
||||
const_cast<VkPipelineShaderStageCreateInfo *>(info.pStages)[mesh_index].module = mesh_shader->get_module();
|
||||
const_cast<VkPipelineShaderStageCreateInfo *>(info.pStages)[frag_index].module = frag_shader->get_module();
|
||||
|
||||
#ifdef VULKAN_DEBUG
|
||||
LOGI("Replaying graphics pipeline.\n");
|
||||
@@ -343,20 +332,11 @@ bool Device::fossilize_replay_compute_pipeline(Fossilize::Hash hash, VkComputePi
|
||||
|
||||
auto *ret = request_program(shader, reinterpret_cast<const ImmutableSamplerBank *>(info.layout));
|
||||
|
||||
if (ret)
|
||||
{
|
||||
// The layout is dummy, resolve it here.
|
||||
info.layout = ret->get_pipeline_layout()->get_layout();
|
||||
// The layout is dummy, resolve it here.
|
||||
info.layout = ret->get_pipeline_layout()->get_layout();
|
||||
|
||||
// Resolve shader module.
|
||||
info.stage.module = shader->get_module();
|
||||
}
|
||||
|
||||
if (!ret || !replayer_state->feature_filter->compute_pipeline_is_supported(&info))
|
||||
{
|
||||
replayer_state->progress.pipelines.fetch_add(1, std::memory_order_release);
|
||||
return true;
|
||||
}
|
||||
// Resolve shader module.
|
||||
info.stage.module = shader->get_module();
|
||||
|
||||
#ifdef VULKAN_DEBUG
|
||||
LOGI("Replaying compute pipeline.\n");
|
||||
@@ -399,6 +379,13 @@ bool Device::enqueue_create_graphics_pipeline(Fossilize::Hash hash,
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!replayer_state->feature_filter->graphics_pipeline_is_supported(create_info))
|
||||
{
|
||||
*pipeline = VK_NULL_HANDLE;
|
||||
replayer_state->progress.pipelines.fetch_add(1, std::memory_order_release);
|
||||
return true;
|
||||
}
|
||||
|
||||
// The lifetime of create_info is tied to the replayer itself.
|
||||
replayer_state->graphics_pipelines.emplace_back(hash, const_cast<VkGraphicsPipelineCreateInfo *>(create_info));
|
||||
return true;
|
||||
@@ -415,6 +402,13 @@ bool Device::enqueue_create_compute_pipeline(Fossilize::Hash hash,
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!replayer_state->feature_filter->compute_pipeline_is_supported(create_info))
|
||||
{
|
||||
*pipeline = VK_NULL_HANDLE;
|
||||
replayer_state->progress.pipelines.fetch_add(1, std::memory_order_release);
|
||||
return true;
|
||||
}
|
||||
|
||||
// The lifetime of create_info is tied to the replayer itself.
|
||||
replayer_state->compute_pipelines.emplace_back(hash, const_cast<VkComputePipelineCreateInfo *>(create_info));
|
||||
return true;
|
||||
@@ -701,9 +695,7 @@ void Device::init_pipeline_state(const Fossilize::FeatureFilter &filter,
|
||||
|
||||
lock.read_only_cache.lock_read();
|
||||
|
||||
// Only non-const usage is to register modules, and that is atomic within the implementation.
|
||||
replayer_state->feature_filter = const_cast<Fossilize::FeatureFilter *>(&filter);
|
||||
|
||||
replayer_state->feature_filter = &filter;
|
||||
auto *group = get_system_handles().thread_group;
|
||||
|
||||
auto shader_manager_task = group->create_task([this]() {
|
||||
|
||||
@@ -50,7 +50,7 @@ struct Device::ReplayerState
|
||||
Fossilize::StateReplayer base_replayer;
|
||||
Fossilize::StateReplayer graphics_replayer;
|
||||
Fossilize::StateReplayer compute_replayer;
|
||||
Fossilize::FeatureFilter *feature_filter = nullptr;
|
||||
const Fossilize::FeatureFilter *feature_filter = nullptr;
|
||||
std::unique_ptr<Fossilize::DatabaseInterface> db;
|
||||
Granite::TaskGroupHandle complete;
|
||||
Granite::TaskGroupHandle module_ready;
|
||||
|
||||
@@ -55,11 +55,11 @@ void FenceHolder::wait()
|
||||
if (timeline_value != 0)
|
||||
{
|
||||
VK_ASSERT(timeline_semaphore);
|
||||
VkSemaphoreWaitInfo info = { VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO };
|
||||
VkSemaphoreWaitInfoKHR info = { VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR };
|
||||
info.semaphoreCount = 1;
|
||||
info.pSemaphores = &timeline_semaphore;
|
||||
info.pValues = &timeline_value;
|
||||
if (table.vkWaitSemaphores(device->get_device(), &info, UINT64_MAX) != VK_SUCCESS)
|
||||
if (table.vkWaitSemaphoresKHR(device->get_device(), &info, UINT64_MAX) != VK_SUCCESS)
|
||||
LOGE("Failed to wait for timeline semaphore!\n");
|
||||
else
|
||||
observed_wait = true;
|
||||
@@ -92,16 +92,16 @@ bool FenceHolder::wait_timeout(uint64_t timeout)
|
||||
if (timeout == 0)
|
||||
{
|
||||
uint64_t current_value = 0;
|
||||
ret = table.vkGetSemaphoreCounterValue(device->get_device(), timeline_semaphore, ¤t_value) == VK_SUCCESS &&
|
||||
ret = table.vkGetSemaphoreCounterValueKHR(device->get_device(), timeline_semaphore, ¤t_value) == VK_SUCCESS &&
|
||||
current_value >= timeline_value;
|
||||
}
|
||||
else
|
||||
{
|
||||
VkSemaphoreWaitInfo info = {VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO};
|
||||
VkSemaphoreWaitInfoKHR info = {VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR};
|
||||
info.semaphoreCount = 1;
|
||||
info.pSemaphores = &timeline_semaphore;
|
||||
info.pValues = &timeline_value;
|
||||
ret = table.vkWaitSemaphores(device->get_device(), &info, timeout) == VK_SUCCESS;
|
||||
ret = table.vkWaitSemaphoresKHR(device->get_device(), &info, timeout) == VK_SUCCESS;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
@@ -68,6 +68,7 @@ enum ImageMiscFlagBits
|
||||
IMAGE_MISC_MUTABLE_SRGB_BIT = 1 << 2,
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_GRAPHICS_BIT = 1 << 3,
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_ASYNC_COMPUTE_BIT = 1 << 4,
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_ASYNC_GRAPHICS_BIT = 1 << 5,
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_ASYNC_TRANSFER_BIT = 1 << 6,
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_VIDEO_DECODE_BIT = 1 << 7,
|
||||
IMAGE_MISC_VERIFY_FORMAT_FEATURE_SAMPLED_LINEAR_FILTER_BIT = 1 << 8,
|
||||
@@ -75,10 +76,15 @@ enum ImageMiscFlagBits
|
||||
IMAGE_MISC_FORCE_NO_DEDICATED_BIT = 1 << 10,
|
||||
IMAGE_MISC_NO_DEFAULT_VIEWS_BIT = 1 << 11,
|
||||
IMAGE_MISC_EXTERNAL_MEMORY_BIT = 1 << 12,
|
||||
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_VIDEO_ENCODE_BIT = 1 << 13,
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_VIDEO_DUPLEX =
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_VIDEO_DECODE_BIT |
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_VIDEO_ENCODE_BIT,
|
||||
#else
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_VIDEO_DUPLEX =
|
||||
IMAGE_MISC_CONCURRENT_QUEUE_VIDEO_DECODE_BIT,
|
||||
#endif
|
||||
};
|
||||
using ImageMiscFlags = uint32_t;
|
||||
|
||||
|
||||
@@ -75,11 +75,6 @@ IndirectLayout::IndirectLayout(Device *device_, const IndirectLayoutToken *token
|
||||
token.tokenType = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV;
|
||||
break;
|
||||
|
||||
case IndirectLayoutToken::Type::Dispatch:
|
||||
token.tokenType = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV;
|
||||
info.pipelineBindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;
|
||||
break;
|
||||
|
||||
default:
|
||||
LOGE("Invalid token type.\n");
|
||||
break;
|
||||
@@ -92,7 +87,6 @@ IndirectLayout::IndirectLayout(Device *device_, const IndirectLayoutToken *token
|
||||
|
||||
info.pTokens = nv_tokens.data();
|
||||
info.tokenCount = num_tokens;
|
||||
bind_point = info.pipelineBindPoint;
|
||||
|
||||
auto &table = device->get_device_table();
|
||||
if (table.vkCreateIndirectCommandsLayoutNV(device->get_device(), &info, nullptr, &layout) != VK_SUCCESS)
|
||||
|
||||
@@ -43,7 +43,6 @@ struct IndirectLayoutToken
|
||||
Draw,
|
||||
DrawIndexed,
|
||||
MeshTasks,
|
||||
Dispatch
|
||||
};
|
||||
|
||||
Type type = Type::Invalid;
|
||||
@@ -76,16 +75,10 @@ public:
|
||||
return layout;
|
||||
}
|
||||
|
||||
VkPipelineBindPoint get_bind_point() const
|
||||
{
|
||||
return bind_point;
|
||||
}
|
||||
|
||||
private:
|
||||
friend class Device;
|
||||
|
||||
Device *device;
|
||||
VkIndirectCommandsLayoutNV layout;
|
||||
VkPipelineBindPoint bind_point;
|
||||
};
|
||||
}
|
||||
@@ -31,7 +31,7 @@ constexpr unsigned VULKAN_NUM_ATTACHMENTS = 8;
|
||||
constexpr unsigned VULKAN_NUM_VERTEX_ATTRIBS = 16;
|
||||
constexpr unsigned VULKAN_NUM_VERTEX_BUFFERS = 4;
|
||||
constexpr unsigned VULKAN_PUSH_CONSTANT_SIZE = 128;
|
||||
constexpr unsigned VULKAN_MAX_UBO_SIZE = 64 * 1024;
|
||||
constexpr unsigned VULKAN_MAX_UBO_SIZE = 16 * 1024;
|
||||
constexpr unsigned VULKAN_NUM_USER_SPEC_CONSTANTS = 8;
|
||||
constexpr unsigned VULKAN_NUM_INTERNAL_SPEC_CONSTANTS = 4;
|
||||
constexpr unsigned VULKAN_NUM_TOTAL_SPEC_CONSTANTS =
|
||||
|
||||
@@ -123,11 +123,8 @@ void DeviceAllocation::free_global(DeviceAllocator &allocator, uint32_t size_, u
|
||||
}
|
||||
}
|
||||
|
||||
void ClassAllocator::prepare_allocation(DeviceAllocation *alloc, Util::IntrusiveList<MiniHeap>::Iterator heap_itr,
|
||||
const Util::SuballocationResult &suballoc)
|
||||
void ClassAllocator::prepare_allocation(DeviceAllocation *alloc, MiniHeap &heap, const SuballocationResult &suballoc)
|
||||
{
|
||||
auto &heap = *heap_itr;
|
||||
alloc->heap = heap_itr;
|
||||
alloc->base = heap.allocation.base;
|
||||
alloc->offset = suballoc.offset + heap.allocation.offset;
|
||||
alloc->mask = suballoc.mask;
|
||||
@@ -717,10 +714,10 @@ bool DeviceAllocator::internal_allocate(
|
||||
info.pNext = &priority_info;
|
||||
}
|
||||
|
||||
if (device->get_device_features().vk12_features.bufferDeviceAddress &&
|
||||
if (device->get_device_features().buffer_device_address_features.bufferDeviceAddress &&
|
||||
allocation_mode_supports_bda(mode))
|
||||
{
|
||||
flags_info.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
|
||||
flags_info.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
|
||||
flags_info.pNext = info.pNext;
|
||||
info.pNext = &flags_info;
|
||||
}
|
||||
|
||||
@@ -196,8 +196,7 @@ private:
|
||||
// Implements curious recurring template pattern calls.
|
||||
bool allocate_backing_heap(DeviceAllocation *allocation);
|
||||
void free_backing_heap(DeviceAllocation *allocation);
|
||||
void prepare_allocation(DeviceAllocation *allocation, Util::IntrusiveList<MiniHeap>::Iterator heap_itr,
|
||||
const Util::SuballocationResult &suballoc);
|
||||
void prepare_allocation(DeviceAllocation *allocation, MiniHeap &heap, const SuballocationResult &suballoc);
|
||||
};
|
||||
|
||||
class Allocator
|
||||
|
||||
@@ -253,7 +253,7 @@ bool PerformanceQueryPool::init_counters(const std::vector<std::string> &counter
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!device->get_device_features().vk12_features.hostQueryReset)
|
||||
if (!device->get_device_features().host_query_reset_features.hostQueryReset)
|
||||
{
|
||||
LOGE("Device does not support host query reset.\n");
|
||||
return false;
|
||||
@@ -321,8 +321,7 @@ QueryPool::QueryPool(Device *device_)
|
||||
: device(device_)
|
||||
, table(device_->get_device_table())
|
||||
{
|
||||
supports_timestamp = device->get_gpu_properties().limits.timestampComputeAndGraphics &&
|
||||
device->get_device_features().vk12_features.hostQueryReset;
|
||||
supports_timestamp = device->get_gpu_properties().limits.timestampComputeAndGraphics;
|
||||
|
||||
// Ignore timestampValidBits and friends for now.
|
||||
if (supports_timestamp)
|
||||
@@ -356,7 +355,8 @@ void QueryPool::begin()
|
||||
for (unsigned j = 0; j < pool.index; j++)
|
||||
pool.cookies[j]->signal_timestamp_ticks(pool.query_results[j]);
|
||||
|
||||
table.vkResetQueryPool(device->get_device(), pool.pool, 0, pool.index);
|
||||
if (device->get_device_features().host_query_reset_features.hostQueryReset)
|
||||
table.vkResetQueryPoolEXT(device->get_device(), pool.pool, 0, pool.index);
|
||||
}
|
||||
|
||||
pool_index = 0;
|
||||
@@ -377,7 +377,8 @@ void QueryPool::add_pool()
|
||||
pool.query_results.resize(pool.size);
|
||||
pool.cookies.resize(pool.size);
|
||||
|
||||
table.vkResetQueryPool(device->get_device(), pool.pool, 0, pool.size);
|
||||
if (device->get_device_features().host_query_reset_features.hostQueryReset)
|
||||
table.vkResetQueryPoolEXT(device->get_device(), pool.pool, 0, pool.size);
|
||||
|
||||
pools.push_back(std::move(pool));
|
||||
}
|
||||
@@ -403,8 +404,11 @@ QueryPoolHandle QueryPool::write_timestamp(VkCommandBuffer cmd, VkPipelineStageF
|
||||
auto cookie = QueryPoolHandle(device->handle_pool.query.allocate(device, true));
|
||||
pool.cookies[pool.index] = cookie;
|
||||
|
||||
if (device->get_device_features().vk13_features.synchronization2)
|
||||
table.vkCmdWriteTimestamp2(cmd, stage, pool.pool, pool.index);
|
||||
if (!device->get_device_features().host_query_reset_features.hostQueryReset)
|
||||
table.vkCmdResetQueryPool(cmd, pool.pool, pool.index, 1);
|
||||
|
||||
if (device->get_device_features().sync2_features.synchronization2)
|
||||
table.vkCmdWriteTimestamp2KHR(cmd, stage, pool.pool, pool.index);
|
||||
else
|
||||
{
|
||||
table.vkCmdWriteTimestamp(cmd, static_cast<VkPipelineStageFlagBits>(convert_vk_src_stage2(stage)),
|
||||
|
||||
@@ -31,6 +31,7 @@ struct ImplementationQuirks
|
||||
bool use_transient_color = true;
|
||||
bool use_transient_depth_stencil = true;
|
||||
bool queue_wait_on_submission = false;
|
||||
bool staging_need_device_local = false;
|
||||
bool use_async_compute_post = true;
|
||||
bool render_graph_force_single_queue = false;
|
||||
bool force_no_subgroups = false;
|
||||
@@ -43,6 +44,7 @@ struct ImplementationQuirks
|
||||
struct ImplementationWorkarounds
|
||||
{
|
||||
bool emulate_event_as_pipeline_barrier = false;
|
||||
bool split_binary_timeline_semaphores = false;
|
||||
bool broken_pipeline_cache_control = false;
|
||||
bool force_host_cached = false;
|
||||
bool force_sync1_access = false;
|
||||
|
||||
@@ -34,7 +34,7 @@ using namespace Util;
|
||||
|
||||
namespace Vulkan
|
||||
{
|
||||
void RenderPass::setup_subpasses(const VkRenderPassCreateInfo2 &create_info)
|
||||
void RenderPass::setup_subpasses(const VkRenderPassCreateInfo2KHR &create_info)
|
||||
{
|
||||
auto *attachments = create_info.pAttachments;
|
||||
|
||||
@@ -78,7 +78,7 @@ void RenderPass::setup_subpasses(const VkRenderPassCreateInfo2 &create_info)
|
||||
}
|
||||
}
|
||||
|
||||
RenderPass::RenderPass(Hash hash, Device *device_, const VkRenderPassCreateInfo2 &create_info)
|
||||
RenderPass::RenderPass(Hash hash, Device *device_, const VkRenderPassCreateInfo2KHR &create_info)
|
||||
: IntrusiveHashMapEnabled<RenderPass>(hash)
|
||||
, device(device_)
|
||||
{
|
||||
@@ -105,7 +105,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const VkRenderPassCreateInfo2
|
||||
#ifdef VULKAN_DEBUG
|
||||
LOGI("Creating render pass.\n");
|
||||
#endif
|
||||
if (table.vkCreateRenderPass2(device->get_device(), &create_info, nullptr, &render_pass) != VK_SUCCESS)
|
||||
if (table.vkCreateRenderPass2KHR(device->get_device(), &create_info, nullptr, &render_pass) != VK_SUCCESS)
|
||||
LOGE("Failed to create render pass.");
|
||||
|
||||
#ifdef GRANITE_VULKAN_FOSSILIZE
|
||||
@@ -146,7 +146,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
|
||||
// First, set up attachment descriptions.
|
||||
const unsigned num_attachments = info.num_color_attachments + (info.depth_stencil ? 1 : 0);
|
||||
VkAttachmentDescription2 attachments[VULKAN_NUM_ATTACHMENTS + 1];
|
||||
VkAttachmentDescription2KHR attachments[VULKAN_NUM_ATTACHMENTS + 1];
|
||||
uint32_t implicit_transitions = 0;
|
||||
uint32_t implicit_bottom_of_pipe = 0;
|
||||
|
||||
@@ -177,17 +177,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
ds_load_op = VK_ATTACHMENT_LOAD_OP_LOAD;
|
||||
|
||||
if (info.op_flags & RENDER_PASS_OP_STORE_DEPTH_STENCIL_BIT)
|
||||
{
|
||||
ds_store_op = VK_ATTACHMENT_STORE_OP_STORE;
|
||||
}
|
||||
else if (info.op_flags & RENDER_PASS_OP_PRESERVE_DEPTH_STENCIL_BIT)
|
||||
{
|
||||
ds_store_op = device->get_device_features().supports_store_op_none ?
|
||||
VK_ATTACHMENT_STORE_OP_NONE : VK_ATTACHMENT_STORE_OP_STORE;
|
||||
|
||||
if (ds_load_op != VK_ATTACHMENT_LOAD_OP_LOAD)
|
||||
ds_store_op = VK_ATTACHMENT_STORE_OP_STORE;
|
||||
}
|
||||
|
||||
bool ds_read_only = (info.op_flags & RENDER_PASS_OP_DEPTH_STENCIL_READ_ONLY_BIT) != 0;
|
||||
VkImageLayout depth_stencil_layout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
@@ -205,7 +195,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
color_attachments[i] = info.color_attachments[i]->get_format();
|
||||
auto &image = info.color_attachments[i]->get_image();
|
||||
auto &att = attachments[i];
|
||||
att = { VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 };
|
||||
att = { VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR };
|
||||
att.format = color_attachments[i];
|
||||
att.samples = image.get_create_info().samples;
|
||||
att.loadOp = color_load_op(i);
|
||||
@@ -260,7 +250,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
{
|
||||
auto &image = info.depth_stencil->get_image();
|
||||
auto &att = attachments[info.num_color_attachments];
|
||||
att = { VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 };
|
||||
att = { VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR };
|
||||
att.format = depth_stencil;
|
||||
att.samples = image.get_create_info().samples;
|
||||
att.loadOp = ds_load_op;
|
||||
@@ -310,10 +300,10 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
att.initialLayout = depth_stencil_layout;
|
||||
}
|
||||
|
||||
Util::StackAllocator<VkAttachmentReference2, 1024> reference_allocator;
|
||||
Util::StackAllocator<VkAttachmentReference2KHR, 1024> reference_allocator;
|
||||
Util::StackAllocator<uint32_t, 1024> preserve_allocator;
|
||||
std::vector<VkSubpassDescription2> subpasses(num_subpasses);
|
||||
std::vector<VkSubpassDependency2> external_dependencies;
|
||||
std::vector<VkSubpassDescription2KHR> subpasses(num_subpasses);
|
||||
std::vector<VkSubpassDependency2KHR> external_dependencies;
|
||||
|
||||
for (unsigned i = 0; i < num_subpasses; i++)
|
||||
{
|
||||
@@ -323,7 +313,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
auto *depth = reference_allocator.allocate_cleared(1);
|
||||
|
||||
auto &subpass = subpasses[i];
|
||||
subpass = { VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 };
|
||||
subpass = { VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR };
|
||||
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||||
subpass.colorAttachmentCount = subpass_infos[i].num_color_attachments;
|
||||
subpass.pColorAttachments = colors;
|
||||
@@ -331,7 +321,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
subpass.pInputAttachments = inputs;
|
||||
subpass.pDepthStencilAttachment = depth;
|
||||
|
||||
if (multiview && device->get_device_features().vk11_features.multiview)
|
||||
if (multiview && device->get_device_features().multiview_features.multiview)
|
||||
subpass.viewMask = ((1u << info.num_layers) - 1u) << info.base_layer;
|
||||
else if (multiview)
|
||||
LOGE("Multiview not supported. Pretending render pass is not multiview.");
|
||||
@@ -346,7 +336,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
{
|
||||
auto att = subpass_infos[i].color_attachments[j];
|
||||
VK_ASSERT(att == VK_ATTACHMENT_UNUSED || (att < num_attachments));
|
||||
colors[j].sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
|
||||
colors[j].sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR;
|
||||
colors[j].attachment = att;
|
||||
// Fill in later.
|
||||
colors[j].layout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
@@ -356,7 +346,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
{
|
||||
auto att = subpass_infos[i].input_attachments[j];
|
||||
VK_ASSERT(att == VK_ATTACHMENT_UNUSED || (att < num_attachments));
|
||||
inputs[j].sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
|
||||
inputs[j].sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR;
|
||||
inputs[j].attachment = att;
|
||||
if (att != VK_ATTACHMENT_UNUSED)
|
||||
{
|
||||
@@ -375,14 +365,14 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
{
|
||||
auto att = subpass_infos[i].resolve_attachments[j];
|
||||
VK_ASSERT(att == VK_ATTACHMENT_UNUSED || (att < num_attachments));
|
||||
resolves[j].sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
|
||||
resolves[j].sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR;
|
||||
resolves[j].attachment = att;
|
||||
// Fill in later.
|
||||
resolves[j].layout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
}
|
||||
}
|
||||
|
||||
depth->sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
|
||||
depth->sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR;
|
||||
|
||||
if (info.depth_stencil && subpass_infos[i].depth_stencil_mode != RenderPassInfo::DepthStencil::None)
|
||||
{
|
||||
@@ -397,36 +387,36 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
}
|
||||
}
|
||||
|
||||
const auto find_color = [&](unsigned subpass, unsigned attachment) -> VkAttachmentReference2 * {
|
||||
const auto find_color = [&](unsigned subpass, unsigned attachment) -> VkAttachmentReference2KHR * {
|
||||
auto *colors = subpasses[subpass].pColorAttachments;
|
||||
for (unsigned i = 0; i < subpasses[subpass].colorAttachmentCount; i++)
|
||||
if (colors[i].attachment == attachment)
|
||||
return const_cast<VkAttachmentReference2 *>(&colors[i]);
|
||||
return const_cast<VkAttachmentReference2KHR *>(&colors[i]);
|
||||
return nullptr;
|
||||
};
|
||||
|
||||
const auto find_resolve = [&](unsigned subpass, unsigned attachment) -> VkAttachmentReference2 * {
|
||||
const auto find_resolve = [&](unsigned subpass, unsigned attachment) -> VkAttachmentReference2KHR * {
|
||||
if (!subpasses[subpass].pResolveAttachments)
|
||||
return nullptr;
|
||||
|
||||
auto *resolves = subpasses[subpass].pResolveAttachments;
|
||||
for (unsigned i = 0; i < subpasses[subpass].colorAttachmentCount; i++)
|
||||
if (resolves[i].attachment == attachment)
|
||||
return const_cast<VkAttachmentReference2 *>(&resolves[i]);
|
||||
return const_cast<VkAttachmentReference2KHR *>(&resolves[i]);
|
||||
return nullptr;
|
||||
};
|
||||
|
||||
const auto find_input = [&](unsigned subpass, unsigned attachment) -> VkAttachmentReference2 * {
|
||||
const auto find_input = [&](unsigned subpass, unsigned attachment) -> VkAttachmentReference2KHR * {
|
||||
auto *inputs = subpasses[subpass].pInputAttachments;
|
||||
for (unsigned i = 0; i < subpasses[subpass].inputAttachmentCount; i++)
|
||||
if (inputs[i].attachment == attachment)
|
||||
return const_cast<VkAttachmentReference2 *>(&inputs[i]);
|
||||
return const_cast<VkAttachmentReference2KHR *>(&inputs[i]);
|
||||
return nullptr;
|
||||
};
|
||||
|
||||
const auto find_depth_stencil = [&](unsigned subpass, unsigned attachment) -> VkAttachmentReference2 * {
|
||||
const auto find_depth_stencil = [&](unsigned subpass, unsigned attachment) -> VkAttachmentReference2KHR * {
|
||||
if (subpasses[subpass].pDepthStencilAttachment->attachment == attachment)
|
||||
return const_cast<VkAttachmentReference2 *>(subpasses[subpass].pDepthStencilAttachment);
|
||||
return const_cast<VkAttachmentReference2KHR *>(subpasses[subpass].pDepthStencilAttachment);
|
||||
else
|
||||
return nullptr;
|
||||
};
|
||||
@@ -645,7 +635,6 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
input->layout = current_layout;
|
||||
used = true;
|
||||
last_subpass_for_attachment[attachment] = subpass;
|
||||
input_attachment_read |= 1u << subpass;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -686,7 +675,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
}
|
||||
|
||||
VK_ASSERT(num_subpasses > 0);
|
||||
VkRenderPassCreateInfo2 rp_info = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 };
|
||||
VkRenderPassCreateInfo2KHR rp_info = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR };
|
||||
rp_info.subpassCount = num_subpasses;
|
||||
rp_info.pSubpasses = subpasses.data();
|
||||
rp_info.pAttachments = attachments;
|
||||
@@ -697,7 +686,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
[&](unsigned subpass) {
|
||||
external_dependencies.emplace_back();
|
||||
auto &dep = external_dependencies.back();
|
||||
dep = { VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 };
|
||||
dep = { VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR };
|
||||
dep.srcSubpass = VK_SUBPASS_EXTERNAL;
|
||||
dep.dstSubpass = subpass;
|
||||
|
||||
@@ -736,7 +725,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
for_each_bit(color_self_dependencies | depth_self_dependencies, [&](unsigned subpass) {
|
||||
external_dependencies.emplace_back();
|
||||
auto &dep = external_dependencies.back();
|
||||
dep = { VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 };
|
||||
dep = { VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR };
|
||||
dep.srcSubpass = subpass;
|
||||
dep.dstSubpass = subpass;
|
||||
dep.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
||||
@@ -764,7 +753,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
{
|
||||
external_dependencies.emplace_back();
|
||||
auto &dep = external_dependencies.back();
|
||||
dep = { VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 };
|
||||
dep = { VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR };
|
||||
dep.srcSubpass = subpass - 1;
|
||||
dep.dstSubpass = subpass;
|
||||
dep.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
||||
@@ -793,14 +782,6 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
{
|
||||
dep.dstStageMask |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
||||
dep.dstAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
|
||||
|
||||
// The store op that comes later will need to write and storeOp accesses in WRITE_BIT.
|
||||
// It's unclear if we need this barrier, but VVL complains if we don't ...
|
||||
if (ds_store_op != VK_ATTACHMENT_STORE_OP_NONE &&
|
||||
(depth_stencil_attachment_write & (1u << (subpass - 1))))
|
||||
{
|
||||
dep.dstAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
||||
}
|
||||
}
|
||||
|
||||
if (depth_stencil_attachment_write & (1u << subpass))
|
||||
@@ -829,7 +810,7 @@ RenderPass::RenderPass(Hash hash, Device *device_, const RenderPassInfo &info)
|
||||
LOGI("Creating render pass.\n");
|
||||
#endif
|
||||
auto &table = device->get_device_table();
|
||||
if (table.vkCreateRenderPass2(device->get_device(), &rp_info, nullptr, &render_pass) != VK_SUCCESS)
|
||||
if (table.vkCreateRenderPass2KHR(device->get_device(), &rp_info, nullptr, &render_pass) != VK_SUCCESS)
|
||||
LOGE("Failed to create render pass.");
|
||||
|
||||
#ifdef GRANITE_VULKAN_FOSSILIZE
|
||||
|
||||
@@ -40,8 +40,7 @@ enum RenderPassOp
|
||||
RENDER_PASS_OP_STORE_DEPTH_STENCIL_BIT = 1 << 2,
|
||||
RENDER_PASS_OP_DEPTH_STENCIL_READ_ONLY_BIT = 1 << 3,
|
||||
RENDER_PASS_OP_ENABLE_TRANSIENT_STORE_BIT = 1 << 4,
|
||||
RENDER_PASS_OP_ENABLE_TRANSIENT_LOAD_BIT = 1 << 5,
|
||||
RENDER_PASS_OP_PRESERVE_DEPTH_STENCIL_BIT = 1 << 6
|
||||
RENDER_PASS_OP_ENABLE_TRANSIENT_LOAD_BIT = 1 << 5
|
||||
};
|
||||
using RenderPassOpFlags = uint32_t;
|
||||
|
||||
@@ -91,17 +90,17 @@ class RenderPass : public HashedObject<RenderPass>, public NoCopyNoMove
|
||||
public:
|
||||
struct SubpassInfo
|
||||
{
|
||||
VkAttachmentReference2 color_attachments[VULKAN_NUM_ATTACHMENTS];
|
||||
VkAttachmentReference2KHR color_attachments[VULKAN_NUM_ATTACHMENTS];
|
||||
unsigned num_color_attachments;
|
||||
VkAttachmentReference2 input_attachments[VULKAN_NUM_ATTACHMENTS];
|
||||
VkAttachmentReference2KHR input_attachments[VULKAN_NUM_ATTACHMENTS];
|
||||
unsigned num_input_attachments;
|
||||
VkAttachmentReference2 depth_stencil_attachment;
|
||||
VkAttachmentReference2KHR depth_stencil_attachment;
|
||||
|
||||
unsigned samples;
|
||||
};
|
||||
|
||||
RenderPass(Util::Hash hash, Device *device, const RenderPassInfo &info);
|
||||
RenderPass(Util::Hash hash, Device *device, const VkRenderPassCreateInfo2 &create_info);
|
||||
RenderPass(Util::Hash hash, Device *device, const VkRenderPassCreateInfo2KHR &create_info);
|
||||
~RenderPass();
|
||||
|
||||
unsigned get_num_subpasses() const
|
||||
@@ -132,14 +131,14 @@ public:
|
||||
return subpasses_info[subpass].num_input_attachments;
|
||||
}
|
||||
|
||||
const VkAttachmentReference2 &get_color_attachment(unsigned subpass, unsigned index) const
|
||||
const VkAttachmentReference2KHR &get_color_attachment(unsigned subpass, unsigned index) const
|
||||
{
|
||||
VK_ASSERT(subpass < subpasses_info.size());
|
||||
VK_ASSERT(index < subpasses_info[subpass].num_color_attachments);
|
||||
return subpasses_info[subpass].color_attachments[index];
|
||||
}
|
||||
|
||||
const VkAttachmentReference2 &get_input_attachment(unsigned subpass, unsigned index) const
|
||||
const VkAttachmentReference2KHR &get_input_attachment(unsigned subpass, unsigned index) const
|
||||
{
|
||||
VK_ASSERT(subpass < subpasses_info.size());
|
||||
VK_ASSERT(index < subpasses_info[subpass].num_input_attachments);
|
||||
@@ -168,7 +167,7 @@ private:
|
||||
VkFormat depth_stencil = VK_FORMAT_UNDEFINED;
|
||||
std::vector<SubpassInfo> subpasses_info;
|
||||
|
||||
void setup_subpasses(const VkRenderPassCreateInfo2 &create_info);
|
||||
void setup_subpasses(const VkRenderPassCreateInfo2KHR &create_info);
|
||||
};
|
||||
|
||||
class Framebuffer : public Cookie, public NoCopyNoMove, public InternalSyncEnabled
|
||||
|
||||
@@ -128,7 +128,7 @@ ImmutableYcbcrConversion::ImmutableYcbcrConversion(Util::Hash hash, Device *devi
|
||||
const VkSamplerYcbcrConversionCreateInfo &info)
|
||||
: HashedObject<ImmutableYcbcrConversion>(hash), device(device_)
|
||||
{
|
||||
if (device->get_device_features().vk11_features.samplerYcbcrConversion)
|
||||
if (device->get_device_features().sampler_ycbcr_conversion_features.samplerYcbcrConversion)
|
||||
{
|
||||
if (device->get_device_table().vkCreateSamplerYcbcrConversion(device->get_device(), &info, nullptr,
|
||||
&conversion) != VK_SUCCESS)
|
||||
|
||||
@@ -46,7 +46,7 @@ void SemaphoreHolder::recycle_semaphore()
|
||||
|
||||
if (internal_sync)
|
||||
{
|
||||
if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE || external_compatible_features)
|
||||
if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE_KHR || external_compatible_features)
|
||||
{
|
||||
device->destroy_semaphore_nolock(semaphore);
|
||||
}
|
||||
@@ -64,7 +64,7 @@ void SemaphoreHolder::recycle_semaphore()
|
||||
}
|
||||
else
|
||||
{
|
||||
if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE || external_compatible_features)
|
||||
if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE_KHR || external_compatible_features)
|
||||
{
|
||||
device->destroy_semaphore(semaphore);
|
||||
}
|
||||
@@ -82,23 +82,6 @@ void SemaphoreHolder::recycle_semaphore()
|
||||
}
|
||||
}
|
||||
|
||||
bool SemaphoreHolder::wait_timeline_timeout(uint64_t value, uint64_t timeout)
|
||||
{
|
||||
VK_ASSERT(semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE);
|
||||
VK_ASSERT(is_proxy_timeline());
|
||||
|
||||
VkSemaphoreWaitInfo wait_info = { VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO };
|
||||
wait_info.pSemaphores = &semaphore;
|
||||
wait_info.semaphoreCount = 1;
|
||||
wait_info.pValues = &value;
|
||||
return device->get_device_table().vkWaitSemaphores(device->get_device(), &wait_info, timeout) == VK_SUCCESS;
|
||||
}
|
||||
|
||||
void SemaphoreHolder::wait_timeline(uint64_t value)
|
||||
{
|
||||
wait_timeline_timeout(value, UINT64_MAX);
|
||||
}
|
||||
|
||||
SemaphoreHolder &SemaphoreHolder::operator=(SemaphoreHolder &&other) noexcept
|
||||
{
|
||||
if (this == &other)
|
||||
@@ -141,7 +124,7 @@ ExternalHandle SemaphoreHolder::export_to_handle()
|
||||
|
||||
// Technically we can export early with reference transference, but it's a bit dubious.
|
||||
// We want to remain compatible with copy transference for later, e.g. SYNC_FD.
|
||||
if (!signalled && semaphore_type == VK_SEMAPHORE_TYPE_BINARY)
|
||||
if (!signalled && semaphore_type == VK_SEMAPHORE_TYPE_BINARY_KHR)
|
||||
{
|
||||
LOGE("Cannot export payload from a semaphore that is not queued up for signal.\n");
|
||||
return h;
|
||||
|
||||
@@ -158,9 +158,6 @@ public:
|
||||
|
||||
SemaphoreHolder &operator=(SemaphoreHolder &&other) noexcept;
|
||||
|
||||
void wait_timeline(uint64_t value);
|
||||
bool wait_timeline_timeout(uint64_t value, uint64_t timeout);
|
||||
|
||||
private:
|
||||
friend class Util::ObjectPool<SemaphoreHolder>;
|
||||
SemaphoreHolder(Device *device_, VkSemaphore semaphore_, bool signalled_, bool owned_)
|
||||
|
||||
@@ -353,15 +353,9 @@ static void update_array_info(ResourceLayout &layout, const SPIRType &type, unsi
|
||||
LOGE("Bindless textures can only be used with binding = 0 in a set.\n");
|
||||
|
||||
if (type.basetype != SPIRType::Image || type.image.dim == spv::DimBuffer)
|
||||
{
|
||||
LOGE("Can only use bindless for sampled images.\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
layout.bindless_set_mask |= 1u << set;
|
||||
// Ignore fp_mask for bindless since we can mix and match.
|
||||
layout.sets[set].fp_mask = 0;
|
||||
}
|
||||
|
||||
size = DescriptorSetLayout::UNSIZED_ARRAY;
|
||||
}
|
||||
@@ -565,7 +559,7 @@ Shader::Shader(Hash hash, Device *device_, const uint32_t *data, size_t size,
|
||||
LOGE("Failed to reflect resource layout.\n");
|
||||
#endif
|
||||
|
||||
if (layout.bindless_set_mask != 0 && !device->get_device_features().vk12_features.descriptorIndexing)
|
||||
if (layout.bindless_set_mask != 0 && !device->get_device_features().supports_descriptor_indexing)
|
||||
LOGE("Sufficient features for descriptor indexing is not supported on this device.\n");
|
||||
}
|
||||
|
||||
|
||||
@@ -44,7 +44,9 @@ enum QueueIndices
|
||||
QUEUE_INDEX_COMPUTE,
|
||||
QUEUE_INDEX_TRANSFER,
|
||||
QUEUE_INDEX_VIDEO_DECODE,
|
||||
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
||||
QUEUE_INDEX_VIDEO_ENCODE,
|
||||
#endif
|
||||
QUEUE_INDEX_COUNT
|
||||
};
|
||||
|
||||
|
||||
+74
-331
@@ -22,8 +22,7 @@
|
||||
|
||||
#define NOMINMAX
|
||||
#include "wsi.hpp"
|
||||
#include "environment.hpp"
|
||||
#include <algorithm>
|
||||
#include "quirks.hpp"
|
||||
|
||||
#if defined(ANDROID) && defined(HAVE_SWAPPY)
|
||||
#include "swappy/swappyVk.h"
|
||||
@@ -47,8 +46,12 @@ WSI::WSI()
|
||||
present_frame_latency = 1;
|
||||
#endif
|
||||
|
||||
present_frame_latency = Util::get_environment_uint("GRANITE_VULKAN_PRESENT_WAIT_LATENCY", present_frame_latency);
|
||||
LOGI("Targeting VK_KHR_present_wait latency to %u frames.\n", present_frame_latency);
|
||||
const char *env = getenv("GRANITE_VULKAN_PRESENT_WAIT_LATENCY");
|
||||
if (env)
|
||||
{
|
||||
present_frame_latency = uint32_t(strtoul(env, nullptr, 0));
|
||||
LOGI("Overriding VK_KHR_present_wait latency to %u frames.\n", present_frame_latency);
|
||||
}
|
||||
|
||||
// Primaries are ST.2020 with D65 whitepoint as specified.
|
||||
hdr_metadata.displayPrimaryRed = { 0.708f, 0.292f };
|
||||
@@ -66,11 +69,8 @@ WSI::WSI()
|
||||
void WSI::set_hdr_metadata(const VkHdrMetadataEXT &hdr)
|
||||
{
|
||||
hdr_metadata = hdr;
|
||||
if (swapchain && swapchain_surface_format.colorSpace == VK_COLOR_SPACE_HDR10_ST2084_EXT &&
|
||||
device->get_device_features().supports_hdr_metadata)
|
||||
{
|
||||
if (swapchain && swapchain_surface_format.colorSpace == VK_COLOR_SPACE_HDR10_ST2084_EXT)
|
||||
table->vkSetHdrMetadataEXT(device->get_device(), 1, &swapchain, &hdr_metadata);
|
||||
}
|
||||
}
|
||||
|
||||
void WSIPlatform::set_window_title(const std::string &)
|
||||
@@ -87,11 +87,6 @@ uintptr_t WSIPlatform::get_fullscreen_monitor()
|
||||
return 0;
|
||||
}
|
||||
|
||||
uintptr_t WSIPlatform::get_native_window()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
const VkApplicationInfo *WSIPlatform::get_application_info()
|
||||
{
|
||||
return nullptr;
|
||||
@@ -167,14 +162,6 @@ bool WSI::init_device()
|
||||
device = Util::make_handle<Device>();
|
||||
device->set_context(*context);
|
||||
platform->event_device_created(device.get());
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
dxgi.reset(new DXGIInteropSwapchain);
|
||||
if (!dxgi->init_interop_device(*device))
|
||||
dxgi.reset();
|
||||
else
|
||||
platform->get_frame_timer().reset();
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -183,100 +170,15 @@ bool WSI::init_device(DeviceHandle device_handle)
|
||||
VK_ASSERT(context);
|
||||
device = std::move(device_handle);
|
||||
platform->event_device_created(device.get());
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
dxgi.reset(new DXGIInteropSwapchain);
|
||||
if (!dxgi->init_interop_device(*device))
|
||||
dxgi.reset();
|
||||
else
|
||||
platform->get_frame_timer().reset();
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
bool WSI::init_surface_swapchain_dxgi(unsigned width, unsigned height)
|
||||
{
|
||||
if (!dxgi)
|
||||
return false;
|
||||
|
||||
// Anything fancy like compute present cannot use DXGI.
|
||||
if (current_extra_usage)
|
||||
return false;
|
||||
|
||||
HWND hwnd = reinterpret_cast<HWND>(platform->get_native_window());
|
||||
if (!hwnd)
|
||||
return false;
|
||||
|
||||
VkSurfaceFormatKHR format = {};
|
||||
switch (current_backbuffer_format)
|
||||
{
|
||||
case BackbufferFormat::UNORM:
|
||||
format = { VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
|
||||
break;
|
||||
|
||||
case BackbufferFormat::sRGB:
|
||||
format = { VK_FORMAT_B8G8R8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
|
||||
break;
|
||||
|
||||
case BackbufferFormat::HDR10:
|
||||
format = { VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_COLOR_SPACE_HDR10_ST2084_EXT };
|
||||
break;
|
||||
}
|
||||
|
||||
constexpr unsigned num_images = 3;
|
||||
|
||||
if (!dxgi->init_swapchain(hwnd, format, width, height, num_images))
|
||||
return false;
|
||||
|
||||
LOGI("Initialized DXGI interop swapchain!\n");
|
||||
|
||||
swapchain_width = width;
|
||||
swapchain_height = height;
|
||||
swapchain_aspect_ratio = platform->get_aspect_ratio();
|
||||
swapchain_current_prerotate = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
|
||||
swapchain_surface_format = dxgi->get_current_surface_format();
|
||||
has_acquired_swapchain_index = false;
|
||||
|
||||
const uint32_t queue_present_support = 1u << context->get_queue_info().family_indices[QUEUE_INDEX_GRAPHICS];
|
||||
device->set_swapchain_queue_family_support(queue_present_support);
|
||||
|
||||
swapchain_images.clear();
|
||||
for (unsigned i = 0; i < num_images; i++)
|
||||
swapchain_images.push_back(dxgi->get_vulkan_image(i));
|
||||
|
||||
device->init_swapchain(swapchain_images, swapchain_width, swapchain_height,
|
||||
swapchain_surface_format.format,
|
||||
swapchain_current_prerotate,
|
||||
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
|
||||
|
||||
platform->event_swapchain_destroyed();
|
||||
platform->event_swapchain_created(device.get(), swapchain, swapchain_width, swapchain_height,
|
||||
swapchain_aspect_ratio, num_images,
|
||||
swapchain_surface_format.format,
|
||||
swapchain_surface_format.colorSpace,
|
||||
swapchain_current_prerotate);
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
bool WSI::init_surface_swapchain()
|
||||
{
|
||||
VK_ASSERT(surface == VK_NULL_HANDLE);
|
||||
VK_ASSERT(context);
|
||||
VK_ASSERT(device);
|
||||
|
||||
unsigned width = platform->get_surface_width();
|
||||
unsigned height = platform->get_surface_height();
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
if (init_surface_swapchain_dxgi(width, height))
|
||||
return true;
|
||||
else
|
||||
dxgi.reset();
|
||||
#endif
|
||||
|
||||
surface = platform->create_surface(context->get_instance(), context->get_gpu());
|
||||
if (surface == VK_NULL_HANDLE)
|
||||
{
|
||||
@@ -284,6 +186,8 @@ bool WSI::init_surface_swapchain()
|
||||
return false;
|
||||
}
|
||||
|
||||
unsigned width = platform->get_surface_width();
|
||||
unsigned height = platform->get_surface_height();
|
||||
swapchain_aspect_ratio = platform->get_aspect_ratio();
|
||||
|
||||
VkBool32 supported = VK_FALSE;
|
||||
@@ -344,7 +248,9 @@ bool WSI::init_context_from_platform(unsigned num_thread_indices, const Context:
|
||||
#ifdef HAVE_FFMPEG_VULKAN
|
||||
constexpr ContextCreationFlags video_context_flags =
|
||||
CONTEXT_CREATION_ENABLE_VIDEO_DECODE_BIT |
|
||||
#ifdef HAVE_FFMPEG_VULKAN_ENCODE
|
||||
CONTEXT_CREATION_ENABLE_VIDEO_ENCODE_BIT |
|
||||
#endif
|
||||
CONTEXT_CREATION_ENABLE_VIDEO_H264_BIT |
|
||||
CONTEXT_CREATION_ENABLE_VIDEO_H265_BIT;
|
||||
#else
|
||||
@@ -365,20 +271,18 @@ bool WSI::init_context_from_platform(unsigned num_thread_indices, const Context:
|
||||
|
||||
VkSurfaceKHR tmp_surface = platform->create_surface(new_context->get_instance(), VK_NULL_HANDLE);
|
||||
|
||||
bool ret = new_context->init_device(
|
||||
if (!new_context->init_device(
|
||||
VK_NULL_HANDLE, tmp_surface,
|
||||
device_ext.data(), device_ext.size(),
|
||||
CONTEXT_CREATION_ENABLE_ADVANCED_WSI_BIT | video_context_flags);
|
||||
|
||||
if (tmp_surface)
|
||||
platform->destroy_surface(new_context->get_instance(), tmp_surface);
|
||||
|
||||
if (!ret)
|
||||
CONTEXT_CREATION_ENABLE_ADVANCED_WSI_BIT | video_context_flags))
|
||||
{
|
||||
LOGE("Failed to create Vulkan device.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (tmp_surface)
|
||||
platform->destroy_surface(new_context->get_instance(), tmp_surface);
|
||||
|
||||
return init_from_existing_context(std::move(new_context));
|
||||
}
|
||||
|
||||
@@ -468,11 +372,6 @@ void WSI::drain_swapchain(bool in_tear_down)
|
||||
|
||||
void WSI::tear_down_swapchain()
|
||||
{
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
// We only do explicit teardown on exit.
|
||||
dxgi.reset();
|
||||
#endif
|
||||
|
||||
drain_swapchain(true);
|
||||
platform->event_swapchain_destroyed();
|
||||
table->vkDestroySwapchainKHR(context->get_device(), swapchain, nullptr);
|
||||
@@ -541,16 +440,14 @@ Semaphore WSI::consume_external_release_semaphore()
|
||||
|
||||
void WSI::wait_swapchain_latency()
|
||||
{
|
||||
unsigned effective_latency = low_latency_mode_enable ? 0 : present_frame_latency;
|
||||
|
||||
if (device->get_device_features().present_wait_features.presentWait &&
|
||||
present_last_id > effective_latency &&
|
||||
present_last_id > present_frame_latency &&
|
||||
current_present_mode == PresentMode::SyncToVBlank)
|
||||
{
|
||||
// The effective latency is more like present_frame_latency + 1.
|
||||
// If 0, we wait for vblank, and we must do CPU work and GPU work in one frame
|
||||
// to hit next vblank.
|
||||
uint64_t target = present_last_id - effective_latency;
|
||||
uint64_t target = present_last_id - present_frame_latency;
|
||||
|
||||
#ifdef VULKAN_WSI_TIMING_DEBUG
|
||||
auto begin_wait = Util::get_current_time_nsecs();
|
||||
@@ -568,60 +465,6 @@ void WSI::wait_swapchain_latency()
|
||||
}
|
||||
}
|
||||
|
||||
void WSI::set_low_latency_mode(bool enable)
|
||||
{
|
||||
low_latency_mode_enable = enable;
|
||||
}
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
bool WSI::begin_frame_dxgi()
|
||||
{
|
||||
Semaphore acquire;
|
||||
|
||||
while (!acquire)
|
||||
{
|
||||
if (!dxgi->acquire(acquire, swapchain_index))
|
||||
return false;
|
||||
|
||||
acquire->signal_external();
|
||||
has_acquired_swapchain_index = true;
|
||||
|
||||
// Poll after acquire as well for optimal latency.
|
||||
platform->poll_input();
|
||||
|
||||
// Polling input may trigger a resize event. Trying to present in that situation without ResizeBuffers
|
||||
// cause wonky issues on DXGI.
|
||||
if (platform->should_resize())
|
||||
update_framebuffer(platform->get_surface_width(), platform->get_surface_height());
|
||||
|
||||
// If update_framebuffer caused a resize, we won't have an acquire index anymore, reacquire.
|
||||
if (!has_acquired_swapchain_index)
|
||||
acquire.reset();
|
||||
}
|
||||
|
||||
auto wait_ts = device->write_calibrated_timestamp();
|
||||
if (!dxgi->wait_latency(present_frame_latency))
|
||||
{
|
||||
LOGE("Failed to wait on latency handle.\n");
|
||||
return false;
|
||||
}
|
||||
device->register_time_interval("WSI", std::move(wait_ts), device->write_calibrated_timestamp(),
|
||||
"DXGI wait latency");
|
||||
|
||||
auto frame_time = platform->get_frame_timer().frame();
|
||||
auto elapsed_time = platform->get_frame_timer().get_elapsed();
|
||||
|
||||
smooth_frame_time = frame_time;
|
||||
smooth_elapsed_time = elapsed_time;
|
||||
|
||||
platform->event_frame_tick(frame_time, elapsed_time);
|
||||
platform->event_swapchain_index(device.get(), swapchain_index);
|
||||
device->set_acquire_semaphore(swapchain_index, std::move(acquire));
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
bool WSI::begin_frame()
|
||||
{
|
||||
if (frame_is_external)
|
||||
@@ -632,31 +475,14 @@ bool WSI::begin_frame()
|
||||
#endif
|
||||
|
||||
device->next_frame_context();
|
||||
external_release.reset();
|
||||
|
||||
#ifdef VULKAN_WSI_TIMING_DEBUG
|
||||
auto next_frame_end = Util::get_current_time_nsecs();
|
||||
LOGI("Waited for vacant frame context for %.3f ms.\n", (next_frame_end - next_frame_start) * 1e-6);
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
if (dxgi)
|
||||
{
|
||||
if (platform->should_resize())
|
||||
update_framebuffer(platform->get_surface_width(), platform->get_surface_height());
|
||||
|
||||
if (has_acquired_swapchain_index)
|
||||
return true;
|
||||
return begin_frame_dxgi();
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
if (swapchain == VK_NULL_HANDLE || platform->should_resize() || swapchain_is_suboptimal)
|
||||
update_framebuffer(platform->get_surface_width(), platform->get_surface_height());
|
||||
if (has_acquired_swapchain_index)
|
||||
return true;
|
||||
}
|
||||
if (swapchain == VK_NULL_HANDLE || platform->should_resize() || swapchain_is_suboptimal)
|
||||
update_framebuffer(platform->get_surface_width(), platform->get_surface_height());
|
||||
|
||||
if (swapchain == VK_NULL_HANDLE)
|
||||
{
|
||||
@@ -664,6 +490,11 @@ bool WSI::begin_frame()
|
||||
return false;
|
||||
}
|
||||
|
||||
if (has_acquired_swapchain_index)
|
||||
return true;
|
||||
|
||||
external_release.reset();
|
||||
|
||||
VkResult result;
|
||||
do
|
||||
{
|
||||
@@ -673,24 +504,11 @@ bool WSI::begin_frame()
|
||||
auto acquire_start = Util::get_current_time_nsecs();
|
||||
#endif
|
||||
|
||||
Fence fence;
|
||||
|
||||
// TODO: Improve this with fancier approaches as needed.
|
||||
if (low_latency_mode_enable &&
|
||||
!device->get_device_features().present_wait_features.presentWait &&
|
||||
current_present_mode == PresentMode::SyncToVBlank)
|
||||
{
|
||||
fence = device->request_legacy_fence();
|
||||
}
|
||||
|
||||
auto acquire_ts = device->write_calibrated_timestamp();
|
||||
result = table->vkAcquireNextImageKHR(context->get_device(), swapchain, UINT64_MAX, acquire->get_semaphore(),
|
||||
fence ? fence->get_fence() : VK_NULL_HANDLE, &swapchain_index);
|
||||
VK_NULL_HANDLE, &swapchain_index);
|
||||
device->register_time_interval("WSI", std::move(acquire_ts), device->write_calibrated_timestamp(), "acquire");
|
||||
|
||||
if (fence)
|
||||
fence->wait();
|
||||
|
||||
#if defined(ANDROID)
|
||||
// Android 10 can return suboptimal here, only because of pre-transform.
|
||||
// We don't care about that, and treat this as success.
|
||||
@@ -714,7 +532,6 @@ bool WSI::begin_frame()
|
||||
LOGI("AcquireNextImageKHR is suboptimal, will recreate.\n");
|
||||
#endif
|
||||
swapchain_is_suboptimal = true;
|
||||
LOGW("Swapchain suboptimal.\n");
|
||||
}
|
||||
|
||||
if (result >= 0)
|
||||
@@ -743,7 +560,6 @@ bool WSI::begin_frame()
|
||||
}
|
||||
else if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT)
|
||||
{
|
||||
LOGW("Swapchain out of date.\n");
|
||||
VK_ASSERT(swapchain_width != 0);
|
||||
VK_ASSERT(swapchain_height != 0);
|
||||
|
||||
@@ -763,17 +579,6 @@ bool WSI::begin_frame()
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
bool WSI::end_frame_dxgi()
|
||||
{
|
||||
auto release = device->consume_release_semaphore();
|
||||
VK_ASSERT(release);
|
||||
VK_ASSERT(release->is_signalled());
|
||||
VK_ASSERT(!release->is_pending_wait());
|
||||
return dxgi->present(std::move(release), current_present_mode == PresentMode::SyncToVBlank);
|
||||
}
|
||||
#endif
|
||||
|
||||
bool WSI::end_frame()
|
||||
{
|
||||
device->end_frame_context();
|
||||
@@ -793,16 +598,10 @@ bool WSI::end_frame()
|
||||
|
||||
has_acquired_swapchain_index = false;
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
if (dxgi)
|
||||
return end_frame_dxgi();
|
||||
#endif
|
||||
|
||||
auto release = device->consume_release_semaphore();
|
||||
VK_ASSERT(release);
|
||||
VK_ASSERT(release->is_signalled());
|
||||
VK_ASSERT(!release->is_pending_wait());
|
||||
|
||||
auto release_semaphore = release->get_semaphore();
|
||||
VK_ASSERT(release_semaphore != VK_NULL_HANDLE);
|
||||
|
||||
@@ -935,22 +734,12 @@ void WSI::update_framebuffer(unsigned width, unsigned height)
|
||||
{
|
||||
if (context && device)
|
||||
{
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
if (dxgi)
|
||||
drain_swapchain(false);
|
||||
if (blocking_init_swapchain(width, height))
|
||||
{
|
||||
if (!init_surface_swapchain_dxgi(width, height))
|
||||
LOGE("Failed to resize DXGI swapchain.\n");
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
drain_swapchain(false);
|
||||
if (blocking_init_swapchain(width, height))
|
||||
{
|
||||
device->init_swapchain(swapchain_images, swapchain_width, swapchain_height,
|
||||
swapchain_surface_format.format, swapchain_current_prerotate,
|
||||
current_extra_usage | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
|
||||
}
|
||||
device->init_swapchain(swapchain_images, swapchain_width, swapchain_height, swapchain_surface_format.format,
|
||||
swapchain_current_prerotate,
|
||||
current_extra_usage | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -963,15 +752,6 @@ bool WSI::update_active_presentation_mode(PresentMode mode)
|
||||
if (current_present_mode == mode)
|
||||
return true;
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
// We set this on Present time.
|
||||
if (dxgi)
|
||||
{
|
||||
current_present_mode = mode;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
for (auto m : present_mode_compat_group)
|
||||
{
|
||||
bool match = false;
|
||||
@@ -1090,9 +870,7 @@ bool WSI::blocking_init_swapchain(unsigned width, unsigned height)
|
||||
else if (err == SwapchainError::NoSurface)
|
||||
{
|
||||
LOGW("WSI cannot make forward progress due to minimization, blocking ...\n");
|
||||
device->set_enable_async_thread_frame_context(true);
|
||||
platform->block_until_wsi_forward_progress(*this);
|
||||
device->set_enable_async_thread_frame_context(false);
|
||||
LOGW("Woke up!\n");
|
||||
}
|
||||
} while (err != SwapchainError::None);
|
||||
@@ -1105,6 +883,12 @@ VkSurfaceFormatKHR WSI::find_suitable_present_format(const std::vector<VkSurface
|
||||
size_t format_count = formats.size();
|
||||
VkSurfaceFormatKHR format = { VK_FORMAT_UNDEFINED };
|
||||
|
||||
if (desired_format == BackbufferFormat::HDR10 && !device->get_device_features().supports_hdr_metadata)
|
||||
{
|
||||
LOGW("VK_EXT_hdr_metadata is not supported, ignoring HDR10.\n");
|
||||
return format;
|
||||
}
|
||||
|
||||
VkFormatFeatureFlags features = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
|
||||
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
|
||||
if ((current_extra_usage & VK_IMAGE_USAGE_STORAGE_BIT) != 0)
|
||||
@@ -1121,29 +905,7 @@ VkSurfaceFormatKHR WSI::find_suitable_present_format(const std::vector<VkSurface
|
||||
if (!device->image_format_is_supported(formats[i].format, features))
|
||||
continue;
|
||||
|
||||
if (desired_format == BackbufferFormat::DisplayP3)
|
||||
{
|
||||
if (formats[i].colorSpace == VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT &&
|
||||
(formats[i].format == VK_FORMAT_A2B10G10R10_UNORM_PACK32 ||
|
||||
formats[i].format == VK_FORMAT_A2R10G10B10_UNORM_PACK32))
|
||||
{
|
||||
format = formats[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (desired_format == BackbufferFormat::UNORMPassthrough)
|
||||
{
|
||||
if (formats[i].colorSpace == VK_COLOR_SPACE_PASS_THROUGH_EXT &&
|
||||
(formats[i].format == VK_FORMAT_R8G8B8A8_UNORM ||
|
||||
formats[i].format == VK_FORMAT_B8G8R8A8_UNORM ||
|
||||
formats[i].format == VK_FORMAT_A2B10G10R10_UNORM_PACK32 ||
|
||||
formats[i].format == VK_FORMAT_A2R10G10B10_UNORM_PACK32))
|
||||
{
|
||||
format = formats[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (desired_format == BackbufferFormat::HDR10)
|
||||
if (desired_format == BackbufferFormat::HDR10)
|
||||
{
|
||||
if (formats[i].colorSpace == VK_COLOR_SPACE_HDR10_ST2084_EXT &&
|
||||
(formats[i].format == VK_FORMAT_A2B10G10R10_UNORM_PACK32 ||
|
||||
@@ -1169,8 +931,6 @@ VkSurfaceFormatKHR WSI::find_suitable_present_format(const std::vector<VkSurface
|
||||
if (formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR &&
|
||||
(formats[i].format == VK_FORMAT_R8G8B8A8_UNORM ||
|
||||
formats[i].format == VK_FORMAT_B8G8R8A8_UNORM ||
|
||||
formats[i].format == VK_FORMAT_A2B10G10R10_UNORM_PACK32 ||
|
||||
formats[i].format == VK_FORMAT_A2R10G10B10_UNORM_PACK32 ||
|
||||
formats[i].format == VK_FORMAT_A8B8G8R8_UNORM_PACK32))
|
||||
{
|
||||
format = formats[i];
|
||||
@@ -1199,7 +959,7 @@ struct SurfaceInfo
|
||||
|
||||
static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
VkSurfaceKHR surface, BackbufferFormat format,
|
||||
PresentMode present_mode, SurfaceInfo &info, bool low_latency_mode_enable)
|
||||
PresentMode present_mode, SurfaceInfo &info)
|
||||
{
|
||||
if (surface == VK_NULL_HANDLE)
|
||||
{
|
||||
@@ -1231,11 +991,10 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
else
|
||||
LOGI("Win32: Not running full-screen.\n");
|
||||
|
||||
bool prefer_exclusive = Util::get_environment_bool("GRANITE_EXCLUSIVE_FULL_SCREEN", false) || low_latency_mode_enable;
|
||||
if (ext.driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS)
|
||||
prefer_exclusive = false; // Broken on Intel Windows
|
||||
const char *exclusive = getenv("GRANITE_EXCLUSIVE_FULL_SCREEN");
|
||||
bool prefer_exclusive = exclusive && strtoul(exclusive, nullptr, 0) != 0;
|
||||
|
||||
if (ext.driver_id == VK_DRIVER_ID_AMD_PROPRIETARY && format == BackbufferFormat::HDR10)
|
||||
if (ext.driver_properties.driverID == VK_DRIVER_ID_AMD_PROPRIETARY_KHR && format == BackbufferFormat::HDR10)
|
||||
{
|
||||
LOGI("Win32: HDR requested on AMD Windows. Forcing exclusive fullscreen, or HDR will not work properly.\n");
|
||||
prefer_exclusive = true;
|
||||
@@ -1266,8 +1025,7 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
else
|
||||
{
|
||||
LOGI("Win32: Opting out of exclusive full-screen!\n");
|
||||
info.exclusive_info.fullScreenExclusive =
|
||||
prefer_exclusive ? VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT : VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT;
|
||||
info.exclusive_info.fullScreenExclusive = VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT;
|
||||
}
|
||||
}
|
||||
#else
|
||||
@@ -1316,6 +1074,8 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
// we need to ban certain types of present modes which apparently do not work as we expect.
|
||||
if (info.exclusive_info.fullScreenExclusive == VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT)
|
||||
allow_mailbox = false;
|
||||
else
|
||||
allow_immediate = false;
|
||||
#endif
|
||||
|
||||
for (auto &mode : present_modes)
|
||||
@@ -1329,29 +1089,28 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
}
|
||||
}
|
||||
|
||||
if (swapchain_present_mode == VK_PRESENT_MODE_FIFO_KHR && low_latency_mode_enable)
|
||||
for (auto mode : present_modes)
|
||||
if (mode == VK_PRESENT_MODE_FIFO_RELAXED_KHR)
|
||||
swapchain_present_mode = mode;
|
||||
|
||||
LOGI("Using present mode: %u.\n", swapchain_present_mode);
|
||||
|
||||
// First, query minImageCount without any present mode.
|
||||
// Avoid opting for present mode compat that is pathological in nature,
|
||||
// e.g. Xorg MAILBOX where minImageCount shoots up to 5 for stupid reasons.
|
||||
uint32_t baseline_image_count;
|
||||
if (ext.supports_surface_capabilities2)
|
||||
{
|
||||
VkSurfaceCapabilities2KHR surface_capabilities2 = { VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR };
|
||||
if (vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu, &info.surface_info, &surface_capabilities2) != VK_SUCCESS)
|
||||
return false;
|
||||
info.surface_capabilities = surface_capabilities2.surfaceCapabilities;
|
||||
baseline_image_count = surface_capabilities2.surfaceCapabilities.minImageCount;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (vkGetPhysicalDeviceSurfaceCapabilitiesKHR(gpu, surface, &info.surface_capabilities) != VK_SUCCESS)
|
||||
return false;
|
||||
baseline_image_count = info.surface_capabilities.minImageCount;
|
||||
}
|
||||
|
||||
// Do not exceed this limit when selecting compatible present modes.
|
||||
baseline_image_count = std::max(3u, baseline_image_count);
|
||||
|
||||
// Make sure we query surface caps tied to the present mode for correct results.
|
||||
if (ext.swapchain_maintenance1_features.swapchainMaintenance1 &&
|
||||
ext.supports_surface_capabilities2)
|
||||
@@ -1364,16 +1123,15 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
present_mode_compat_group.resize(32);
|
||||
present_mode_caps.presentModeCount = present_mode_compat_group.size();
|
||||
present_mode_caps.pPresentModes = present_mode_compat_group.data();
|
||||
surface_capabilities2.pNext = &present_mode_caps;
|
||||
|
||||
info.present_mode.pNext = const_cast<void *>(info.surface_info.pNext);
|
||||
info.surface_info.pNext = &info.present_mode;
|
||||
info.present_mode = { VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT };
|
||||
info.present_mode.presentMode = swapchain_present_mode;
|
||||
|
||||
surface_capabilities2.pNext = &present_mode_caps;
|
||||
if (vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu, &info.surface_info, &surface_capabilities2) != VK_SUCCESS)
|
||||
return false;
|
||||
surface_capabilities2.pNext = present_mode_caps.pNext;
|
||||
|
||||
info.surface_capabilities.minImageCount = surface_capabilities2.surfaceCapabilities.minImageCount;
|
||||
present_mode_compat_group.resize(present_mode_caps.presentModeCount);
|
||||
@@ -1387,7 +1145,6 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
|
||||
// Only allow sensible present modes that we know of.
|
||||
if (mode != VK_PRESENT_MODE_FIFO_KHR &&
|
||||
mode != VK_PRESENT_MODE_FIFO_RELAXED_KHR &&
|
||||
mode != VK_PRESENT_MODE_IMMEDIATE_KHR &&
|
||||
mode != VK_PRESENT_MODE_MAILBOX_KHR)
|
||||
{
|
||||
@@ -1398,10 +1155,17 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
if (vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu, &info.surface_info, &surface_capabilities2) != VK_SUCCESS)
|
||||
return false;
|
||||
|
||||
// Accept the present mode if it does not modify minImageCount.
|
||||
// If image count changes, we should probably recreate the swapchain.
|
||||
if (surface_capabilities2.surfaceCapabilities.minImageCount == info.surface_capabilities.minImageCount)
|
||||
// Accept the present mode if it does not increment minImageCount beyond our expectation.
|
||||
// When we use present groups, minImageCount == max(presentMode's minImageCount).
|
||||
// Accept a bump to 3 images, since that's what we expect to use either way.
|
||||
if (surface_capabilities2.surfaceCapabilities.minImageCount <=
|
||||
std::max(baseline_image_count, info.surface_capabilities.minImageCount))
|
||||
{
|
||||
info.present_mode_compat_group.push_back(mode);
|
||||
info.surface_capabilities.minImageCount =
|
||||
std::max(surface_capabilities2.surfaceCapabilities.minImageCount,
|
||||
info.surface_capabilities.minImageCount);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1439,22 +1203,6 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
return false;
|
||||
}
|
||||
|
||||
// Ensure that 10-bit formats come before other formats.
|
||||
std::sort(info.formats.begin(), info.formats.end(), [](const VkSurfaceFormatKHR &a, const VkSurfaceFormatKHR &b) {
|
||||
const auto qual = [](VkFormat fmt) {
|
||||
// Prefer a consistent ordering so Fossilize caches are more effective.
|
||||
if (fmt == VK_FORMAT_A2B10G10R10_UNORM_PACK32)
|
||||
return 3;
|
||||
else if (fmt == VK_FORMAT_A2R10G10B10_UNORM_PACK32)
|
||||
return 2;
|
||||
else if (fmt == VK_FORMAT_B8G8R8A8_UNORM)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
};
|
||||
return qual(a.format) > qual(b.format);
|
||||
});
|
||||
|
||||
// Allow for seamless toggle between presentation modes.
|
||||
if (ext.swapchain_maintenance1_features.swapchainMaintenance1)
|
||||
{
|
||||
@@ -1473,7 +1221,7 @@ static bool init_surface_info(Device &device, WSIPlatform &platform,
|
||||
WSI::SwapchainError WSI::init_swapchain(unsigned width, unsigned height)
|
||||
{
|
||||
SurfaceInfo surface_info = {};
|
||||
if (!init_surface_info(*device, *platform, surface, current_backbuffer_format, current_present_mode, surface_info, low_latency_mode_enable))
|
||||
if (!init_surface_info(*device, *platform, surface, current_backbuffer_format, current_present_mode, surface_info))
|
||||
return SwapchainError::Error;
|
||||
const auto &caps = surface_info.surface_capabilities;
|
||||
|
||||
@@ -1497,13 +1245,10 @@ WSI::SwapchainError WSI::init_swapchain(unsigned width, unsigned height)
|
||||
auto attempt_backbuffer_format = current_backbuffer_format;
|
||||
auto surface_format = find_suitable_present_format(surface_info.formats, attempt_backbuffer_format);
|
||||
|
||||
if (surface_format.format == VK_FORMAT_UNDEFINED &&
|
||||
(attempt_backbuffer_format == BackbufferFormat::HDR10 ||
|
||||
attempt_backbuffer_format == BackbufferFormat::DisplayP3 ||
|
||||
attempt_backbuffer_format == BackbufferFormat::UNORMPassthrough))
|
||||
if (surface_format.format == VK_FORMAT_UNDEFINED && attempt_backbuffer_format == BackbufferFormat::HDR10)
|
||||
{
|
||||
LOGW("Could not find suitable present format for HDR. Attempting fallback to UNORM.\n");
|
||||
attempt_backbuffer_format = BackbufferFormat::UNORM;
|
||||
LOGW("Could not find suitable present format for HDR10. Attempting fallback to sRGB.\n");
|
||||
attempt_backbuffer_format = BackbufferFormat::sRGB;
|
||||
surface_format = find_suitable_present_format(surface_info.formats, attempt_backbuffer_format);
|
||||
}
|
||||
|
||||
@@ -1611,10 +1356,13 @@ WSI::SwapchainError WSI::init_swapchain(unsigned width, unsigned height)
|
||||
swapchain_size.height =
|
||||
std::max(std::min(height, caps.maxImageExtent.height), caps.minImageExtent.height);
|
||||
|
||||
uint32_t desired_swapchain_images =
|
||||
low_latency_mode_enable && current_present_mode == PresentMode::SyncToVBlank ? 2 : 3;
|
||||
uint32_t desired_swapchain_images = 3;
|
||||
{
|
||||
const char *num_images = getenv("GRANITE_VULKAN_SWAPCHAIN_IMAGES");
|
||||
if (num_images)
|
||||
desired_swapchain_images = uint32_t(strtoul(num_images, nullptr, 0));
|
||||
}
|
||||
|
||||
desired_swapchain_images = Util::get_environment_uint("GRANITE_VULKAN_SWAPCHAIN_IMAGES", desired_swapchain_images);
|
||||
LOGI("Targeting %u swapchain images.\n", desired_swapchain_images);
|
||||
|
||||
if (desired_swapchain_images < caps.minImageCount)
|
||||
@@ -1714,11 +1462,8 @@ WSI::SwapchainError WSI::init_swapchain(unsigned width, unsigned height)
|
||||
swapchain_surface_format.colorSpace,
|
||||
swapchain_current_prerotate);
|
||||
|
||||
if (swapchain_surface_format.colorSpace == VK_COLOR_SPACE_HDR10_ST2084_EXT &&
|
||||
device->get_device_features().supports_hdr_metadata)
|
||||
{
|
||||
if (swapchain_surface_format.colorSpace == VK_COLOR_SPACE_HDR10_ST2084_EXT)
|
||||
table->vkSetHdrMetadataEXT(device->get_device(), 1, &swapchain, &hdr_metadata);
|
||||
}
|
||||
|
||||
return SwapchainError::None;
|
||||
}
|
||||
@@ -1751,6 +1496,4 @@ void WSIPlatform::event_swapchain_created(Device *, VkSwapchainKHR, unsigned, un
|
||||
void WSIPlatform::event_swapchain_destroyed() {}
|
||||
void WSIPlatform::event_frame_tick(double, double) {}
|
||||
void WSIPlatform::event_swapchain_index(Device *, unsigned) {}
|
||||
void WSIPlatform::begin_drop_event() {}
|
||||
void WSIPlatform::show_message_box(const std::string &, Vulkan::WSIPlatform::MessageType) {}
|
||||
}
|
||||
+3
-33
@@ -29,16 +29,6 @@
|
||||
#include <vector>
|
||||
#include <thread>
|
||||
#include <chrono>
|
||||
#include <memory>
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
#include "wsi_dxgi.hpp"
|
||||
#endif
|
||||
|
||||
namespace Granite
|
||||
{
|
||||
class InputTrackerHandler;
|
||||
}
|
||||
|
||||
namespace Vulkan
|
||||
{
|
||||
@@ -73,6 +63,7 @@ public:
|
||||
resize = false;
|
||||
current_swapchain_width = width;
|
||||
current_swapchain_height = height;
|
||||
swapchain_dimension_update_timestamp++;
|
||||
}
|
||||
|
||||
virtual uint32_t get_surface_width() = 0;
|
||||
@@ -85,7 +76,6 @@ public:
|
||||
|
||||
virtual bool alive(WSI &wsi) = 0;
|
||||
virtual void poll_input() = 0;
|
||||
virtual void poll_input_async(Granite::InputTrackerHandler *handler) = 0;
|
||||
virtual bool has_external_swapchain()
|
||||
{
|
||||
return false;
|
||||
@@ -125,18 +115,13 @@ public:
|
||||
virtual void set_window_title(const std::string &title);
|
||||
|
||||
virtual uintptr_t get_fullscreen_monitor();
|
||||
virtual uintptr_t get_native_window();
|
||||
|
||||
virtual const VkApplicationInfo *get_application_info();
|
||||
|
||||
virtual void begin_drop_event();
|
||||
|
||||
enum class MessageType { Error, Warning, Info };
|
||||
virtual void show_message_box(const std::string &str, MessageType type);
|
||||
|
||||
protected:
|
||||
unsigned current_swapchain_width = 0;
|
||||
unsigned current_swapchain_height = 0;
|
||||
uint64_t swapchain_dimension_update_timestamp = 0;
|
||||
bool resize = false;
|
||||
|
||||
private:
|
||||
@@ -155,9 +140,7 @@ enum class BackbufferFormat
|
||||
{
|
||||
UNORM,
|
||||
sRGB,
|
||||
HDR10,
|
||||
DisplayP3,
|
||||
UNORMPassthrough
|
||||
HDR10
|
||||
};
|
||||
|
||||
class WSI
|
||||
@@ -167,11 +150,6 @@ public:
|
||||
void set_platform(WSIPlatform *platform);
|
||||
void set_present_mode(PresentMode mode);
|
||||
void set_backbuffer_format(BackbufferFormat format);
|
||||
|
||||
// Latency is normally pretty low, but this aims to target
|
||||
// really low latency. Only suitable for cases where rendering loads are extremely simple.
|
||||
void set_low_latency_mode(bool enable);
|
||||
|
||||
inline BackbufferFormat get_backbuffer_format() const
|
||||
{
|
||||
return backbuffer_format;
|
||||
@@ -304,7 +282,6 @@ private:
|
||||
VkSurfaceFormatKHR swapchain_surface_format = { VK_FORMAT_UNDEFINED, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
|
||||
PresentMode current_present_mode = PresentMode::SyncToVBlank;
|
||||
PresentMode present_mode = PresentMode::SyncToVBlank;
|
||||
bool low_latency_mode_enable = false;
|
||||
|
||||
VkPresentModeKHR active_present_mode = VK_PRESENT_MODE_FIFO_KHR;
|
||||
std::vector<VkPresentModeKHR> present_mode_compat_group;
|
||||
@@ -367,12 +344,5 @@ private:
|
||||
void nonblock_delete_swapchains();
|
||||
|
||||
VkSurfaceFormatKHR find_suitable_present_format(const std::vector<VkSurfaceFormatKHR> &formats, BackbufferFormat desired_format) const;
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
std::unique_ptr<DXGIInteropSwapchain> dxgi;
|
||||
bool init_surface_swapchain_dxgi(unsigned width, unsigned height);
|
||||
bool begin_frame_dxgi();
|
||||
bool end_frame_dxgi();
|
||||
#endif
|
||||
};
|
||||
}
|
||||
@@ -56,10 +56,6 @@ void MupenWSIPlatform::poll_input()
|
||||
{
|
||||
}
|
||||
|
||||
void MupenWSIPlatform::poll_input_async(Granite::InputTrackerHandler *handler)
|
||||
{
|
||||
}
|
||||
|
||||
void MupenWSIPlatform::do_resize()
|
||||
{
|
||||
resize = true;
|
||||
|
||||
@@ -13,7 +13,6 @@ public:
|
||||
uint32_t get_surface_height() override;
|
||||
bool alive(Vulkan::WSI &wsi) override;
|
||||
void poll_input() override;
|
||||
void poll_input_async(Granite::InputTrackerHandler *handler) override;
|
||||
void do_resize();
|
||||
};
|
||||
|
||||
|
||||
Reference in new issue
Block a user