mirror of
https://github.com/LostRuins/koboldcpp.git
synced 2026-09-20 01:31:42 +02:00
merge checkpoint 2 - functional merge without q4_0_4_4 (need regen shaders)
This commit is contained in:
Concedo
@@ -0,0 +1,201 @@
|
||||
/* Copyright (c) 2015-2017, 2019-2024 The Khronos Group Inc.
|
||||
* Copyright (c) 2015-2017, 2019-2024 Valve Corporation
|
||||
* Copyright (c) 2015-2017, 2019-2024 LunarG, Inc.
|
||||
* Modifications Copyright (C) 2022 RasterGrid Kft.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <functional>
|
||||
#include <mutex>
|
||||
#include <shared_mutex>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
namespace vku {
|
||||
namespace concurrent {
|
||||
// https://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size
|
||||
// https://en.wikipedia.org/wiki/False_sharing
|
||||
// TODO use C++20 to check for std::hardware_destructive_interference_size feature support.
|
||||
constexpr std::size_t get_hardware_destructive_interference_size() { return 64; }
|
||||
|
||||
// Limited concurrent unordered_map that supports internally-synchronized
|
||||
// insert/erase/access. Splits locking across N buckets and uses shared_mutex
|
||||
// for read/write locking. Iterators are not supported. The following
|
||||
// operations are supported:
|
||||
//
|
||||
// insert_or_assign: Insert a new element or update an existing element.
|
||||
// insert: Insert a new element and return whether it was inserted.
|
||||
// erase: Remove an element.
|
||||
// contains: Returns true if the key is in the map.
|
||||
// find: Returns != end() if found, value is in ret->second.
|
||||
// pop: Erases and returns the erased value if found.
|
||||
//
|
||||
// find/end: find returns a vaguely iterator-like type that can be compared to
|
||||
// end and can use iter->second to retrieve the reference. This is to ease porting
|
||||
// for existing code that combines the existence check and lookup in a single
|
||||
// operation (and thus a single lock). i.e.:
|
||||
//
|
||||
// auto iter = map.find(key);
|
||||
// if (iter != map.end()) {
|
||||
// T t = iter->second;
|
||||
// ...
|
||||
//
|
||||
// snapshot: Return an array of elements (key, value pairs) that satisfy an optional
|
||||
// predicate. This can be used as a substitute for iterators in exceptional cases.
|
||||
template <typename Key, typename T, int BUCKETSLOG2 = 2, typename Map = std::unordered_map<Key, T>>
|
||||
class unordered_map {
|
||||
// Aliases to avoid excessive typing. We can't easily auto these away because
|
||||
// there are virtual methods in ValidationObject which return lock guards
|
||||
// and those cannot use return type deduction.
|
||||
using ReadLockGuard = std::shared_lock<std::shared_mutex>;
|
||||
using WriteLockGuard = std::unique_lock<std::shared_mutex>;
|
||||
|
||||
public:
|
||||
template <typename... Args>
|
||||
void insert_or_assign(const Key &key, Args &&...args) {
|
||||
uint32_t h = ConcurrentMapHashObject(key);
|
||||
WriteLockGuard lock(locks[h].lock);
|
||||
maps[h][key] = {std::forward<Args>(args)...};
|
||||
}
|
||||
|
||||
template <typename... Args>
|
||||
bool insert(const Key &key, Args &&...args) {
|
||||
uint32_t h = ConcurrentMapHashObject(key);
|
||||
WriteLockGuard lock(locks[h].lock);
|
||||
auto ret = maps[h].emplace(key, std::forward<Args>(args)...);
|
||||
return ret.second;
|
||||
}
|
||||
|
||||
// returns size_type
|
||||
size_t erase(const Key &key) {
|
||||
uint32_t h = ConcurrentMapHashObject(key);
|
||||
WriteLockGuard lock(locks[h].lock);
|
||||
return maps[h].erase(key);
|
||||
}
|
||||
|
||||
bool contains(const Key &key) const {
|
||||
uint32_t h = ConcurrentMapHashObject(key);
|
||||
ReadLockGuard lock(locks[h].lock);
|
||||
return maps[h].count(key) != 0;
|
||||
}
|
||||
|
||||
// type returned by find() and end().
|
||||
class FindResult {
|
||||
public:
|
||||
FindResult(bool a, T b) : result(a, std::move(b)) {}
|
||||
|
||||
// == and != only support comparing against end()
|
||||
bool operator==(const FindResult &other) const {
|
||||
if (result.first == false && other.result.first == false) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator!=(const FindResult &other) const { return !(*this == other); }
|
||||
|
||||
// Make -> act kind of like an iterator.
|
||||
std::pair<bool, T> *operator->() { return &result; }
|
||||
const std::pair<bool, T> *operator->() const { return &result; }
|
||||
|
||||
private:
|
||||
// (found, reference to element)
|
||||
std::pair<bool, T> result;
|
||||
};
|
||||
|
||||
// find()/end() return a FindResult containing a copy of the value. For end(),
|
||||
// return a default value.
|
||||
FindResult end() const { return FindResult(false, T()); }
|
||||
FindResult cend() const { return end(); }
|
||||
|
||||
FindResult find(const Key &key) const {
|
||||
uint32_t h = ConcurrentMapHashObject(key);
|
||||
ReadLockGuard lock(locks[h].lock);
|
||||
|
||||
auto itr = maps[h].find(key);
|
||||
const bool found = itr != maps[h].end();
|
||||
|
||||
if (found) {
|
||||
return FindResult(true, itr->second);
|
||||
} else {
|
||||
return end();
|
||||
}
|
||||
}
|
||||
|
||||
FindResult pop(const Key &key) {
|
||||
uint32_t h = ConcurrentMapHashObject(key);
|
||||
WriteLockGuard lock(locks[h].lock);
|
||||
|
||||
auto itr = maps[h].find(key);
|
||||
const bool found = itr != maps[h].end();
|
||||
|
||||
if (found) {
|
||||
auto ret = FindResult(true, itr->second);
|
||||
maps[h].erase(itr);
|
||||
return ret;
|
||||
} else {
|
||||
return end();
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::pair<const Key, T>> snapshot(std::function<bool(T)> f = nullptr) const {
|
||||
std::vector<std::pair<const Key, T>> ret;
|
||||
for (int h = 0; h < BUCKETS; ++h) {
|
||||
ReadLockGuard lock(locks[h].lock);
|
||||
for (const auto &j : maps[h]) {
|
||||
if (!f || f(j.second)) {
|
||||
ret.emplace_back(j.first, j.second);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void clear() {
|
||||
for (int h = 0; h < BUCKETS; ++h) {
|
||||
WriteLockGuard lock(locks[h].lock);
|
||||
maps[h].clear();
|
||||
}
|
||||
}
|
||||
|
||||
size_t size() const {
|
||||
size_t result = 0;
|
||||
for (int h = 0; h < BUCKETS; ++h) {
|
||||
ReadLockGuard lock(locks[h].lock);
|
||||
result += maps[h].size();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
bool empty() const {
|
||||
bool result = 0;
|
||||
for (int h = 0; h < BUCKETS; ++h) {
|
||||
ReadLockGuard lock(locks[h].lock);
|
||||
result |= maps[h].empty();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private:
|
||||
static const int BUCKETS = (1 << BUCKETSLOG2);
|
||||
|
||||
Map maps[BUCKETS];
|
||||
struct alignas(get_hardware_destructive_interference_size()) AlignedSharedMutex {
|
||||
std::shared_mutex lock;
|
||||
};
|
||||
mutable std::array<AlignedSharedMutex, BUCKETS> locks;
|
||||
|
||||
uint32_t ConcurrentMapHashObject(const Key &object) const {
|
||||
uint64_t u64 = (uint64_t)(uintptr_t)object;
|
||||
uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64;
|
||||
hash ^= (hash >> BUCKETSLOG2) ^ (hash >> (2 * BUCKETSLOG2));
|
||||
hash &= (BUCKETS - 1);
|
||||
return hash;
|
||||
}
|
||||
};
|
||||
} // namespace concurrent
|
||||
} // namespace vku
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,124 @@
|
||||
/***************************************************************************
|
||||
*
|
||||
* Copyright (c) 2015-2024 The Khronos Group Inc.
|
||||
* Copyright (c) 2015-2024 Valve Corporation
|
||||
* Copyright (c) 2015-2024 LunarG, Inc.
|
||||
* Copyright (c) 2015-2024 Google Inc.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#pragma once
|
||||
#include <vulkan/vulkan.h>
|
||||
#include <cassert>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
|
||||
namespace vku {
|
||||
|
||||
// State that elements in a pNext chain may need to be aware of
|
||||
struct PNextCopyState {
|
||||
// Custom initialization function. Returns true if the structure passed to init was initialized, false otherwise
|
||||
std::function<bool(VkBaseOutStructure* /* safe_sruct */, const VkBaseOutStructure* /* in_struct */)> init;
|
||||
};
|
||||
|
||||
void* SafePnextCopy(const void* pNext, PNextCopyState* copy_state = {});
|
||||
void FreePnextChain(const void* pNext);
|
||||
char* SafeStringCopy(const char* in_string);
|
||||
|
||||
template <typename Base, typename T>
|
||||
bool AddToPnext(Base& base, const T& data) {
|
||||
assert(base.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs.
|
||||
auto** prev = reinterpret_cast<VkBaseOutStructure**>(const_cast<void**>(&base.pNext));
|
||||
auto* current = *prev;
|
||||
while (current) {
|
||||
if (data.sType == current->sType) {
|
||||
return false;
|
||||
}
|
||||
prev = reinterpret_cast<VkBaseOutStructure**>(¤t->pNext);
|
||||
current = *prev;
|
||||
}
|
||||
*prev = reinterpret_cast<VkBaseOutStructure*>(SafePnextCopy(&data));
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Base>
|
||||
bool RemoveFromPnext(Base& base, VkStructureType t) {
|
||||
assert(base.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs.
|
||||
auto** prev = reinterpret_cast<VkBaseOutStructure**>(const_cast<void**>(&base.pNext));
|
||||
auto* current = *prev;
|
||||
while (current) {
|
||||
if (t == current->sType) {
|
||||
*prev = current->pNext;
|
||||
current->pNext = nullptr;
|
||||
FreePnextChain(current);
|
||||
return true;
|
||||
}
|
||||
prev = reinterpret_cast<VkBaseOutStructure**>(¤t->pNext);
|
||||
current = *prev;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename CreateInfo>
|
||||
uint32_t FindExtension(CreateInfo& ci, const char* extension_name) {
|
||||
assert(ci.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs.
|
||||
for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) {
|
||||
if (strcmp(ci.ppEnabledExtensionNames[i], extension_name) == 0) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return ci.enabledExtensionCount;
|
||||
}
|
||||
|
||||
template <typename CreateInfo>
|
||||
bool AddExtension(CreateInfo& ci, const char* extension_name) {
|
||||
assert(ci.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs.
|
||||
uint32_t pos = FindExtension(ci, extension_name);
|
||||
if (pos < ci.enabledExtensionCount) {
|
||||
// already present
|
||||
return false;
|
||||
}
|
||||
char** exts = new char*[ci.enabledExtensionCount + 1];
|
||||
memcpy(exts, ci.ppEnabledExtensionNames, sizeof(char*) * ci.enabledExtensionCount);
|
||||
exts[ci.enabledExtensionCount] = SafeStringCopy(extension_name);
|
||||
delete[] ci.ppEnabledExtensionNames;
|
||||
ci.ppEnabledExtensionNames = exts;
|
||||
ci.enabledExtensionCount++;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename CreateInfo>
|
||||
bool RemoveExtension(CreateInfo& ci, const char* extension_name) {
|
||||
assert(ci.ptr()); // All safe struct have a ptr() method. Prevent use with non-safe structs.
|
||||
uint32_t pos = FindExtension(ci, extension_name);
|
||||
if (pos >= ci.enabledExtensionCount) {
|
||||
// not present
|
||||
return false;
|
||||
}
|
||||
if (ci.enabledExtensionCount == 1) {
|
||||
delete[] ci.ppEnabledExtensionNames[0];
|
||||
delete[] ci.ppEnabledExtensionNames;
|
||||
ci.ppEnabledExtensionNames = nullptr;
|
||||
ci.enabledExtensionCount = 0;
|
||||
return true;
|
||||
}
|
||||
uint32_t out_pos = 0;
|
||||
char** exts = new char*[ci.enabledExtensionCount - 1];
|
||||
for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) {
|
||||
if (i == pos) {
|
||||
delete[] ci.ppEnabledExtensionNames[i];
|
||||
} else {
|
||||
exts[out_pos++] = const_cast<char*>(ci.ppEnabledExtensionNames[i]);
|
||||
}
|
||||
}
|
||||
delete[] ci.ppEnabledExtensionNames;
|
||||
ci.ppEnabledExtensionNames = exts;
|
||||
ci.enabledExtensionCount--;
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace vku
|
||||
@@ -0,0 +1,713 @@
|
||||
/* Copyright (c) 2015-2017, 2019-2024 The Khronos Group Inc.
|
||||
* Copyright (c) 2015-2017, 2019-2024 Valve Corporation
|
||||
* Copyright (c) 2015-2017, 2019-2024 LunarG, Inc.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cassert>
|
||||
#include <memory>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
|
||||
namespace vku {
|
||||
namespace small {
|
||||
|
||||
// A vector class with "small string optimization" -- meaning that the class contains a fixed working store for N elements.
|
||||
// Useful in in situations where the needed size is unknown, but the typical size is known If size increases beyond the
|
||||
// fixed capacity, a dynamically allocated working store is created.
|
||||
//
|
||||
// NOTE: Unlike std::vector which only requires T to be CopyAssignable and CopyConstructable, small::vector requires T to be
|
||||
// MoveAssignable and MoveConstructable
|
||||
// NOTE: Unlike std::vector, iterators are invalidated by move assignment between small::vector objects effectively the
|
||||
// "small string" allocation functions as an incompatible allocator.
|
||||
template <typename T, size_t N, typename SizeType = uint32_t>
|
||||
class vector {
|
||||
public:
|
||||
using value_type = T;
|
||||
using reference = value_type &;
|
||||
using const_reference = const value_type &;
|
||||
using pointer = value_type *;
|
||||
using const_pointer = const value_type *;
|
||||
using iterator = pointer;
|
||||
using const_iterator = const_pointer;
|
||||
using size_type = SizeType;
|
||||
static const size_type kSmallCapacity = N;
|
||||
static const size_type kMaxCapacity = std::numeric_limits<size_type>::max();
|
||||
static_assert(N <= kMaxCapacity, "size must be less than size_type::max");
|
||||
|
||||
vector() : size_(0), capacity_(N), working_store_(GetSmallStore()) {}
|
||||
|
||||
vector(std::initializer_list<T> list) : size_(0), capacity_(N), working_store_(GetSmallStore()) { PushBackFrom(list); }
|
||||
|
||||
vector(const vector &other) : size_(0), capacity_(N), working_store_(GetSmallStore()) { PushBackFrom(other); }
|
||||
|
||||
vector(vector &&other) : size_(0), capacity_(N), working_store_(GetSmallStore()) {
|
||||
if (other.large_store_) {
|
||||
MoveLargeStore(other);
|
||||
} else {
|
||||
PushBackFrom(std::move(other));
|
||||
}
|
||||
// Per the spec, when constructing from other, other is guaranteed to be empty after the constructor runs
|
||||
other.clear();
|
||||
}
|
||||
|
||||
vector(size_type size, const value_type &value = value_type()) : size_(0), capacity_(N), working_store_(GetSmallStore()) {
|
||||
reserve(size);
|
||||
auto dest = GetWorkingStore();
|
||||
for (size_type i = 0; i < size; i++) {
|
||||
new (dest) value_type(value);
|
||||
++dest;
|
||||
}
|
||||
size_ = size;
|
||||
}
|
||||
|
||||
~vector() { clear(); }
|
||||
|
||||
bool operator==(const vector &rhs) const {
|
||||
if (size_ != rhs.size_) return false;
|
||||
auto value = begin();
|
||||
for (const auto &rh_value : rhs) {
|
||||
if (!(*value == rh_value)) {
|
||||
return false;
|
||||
}
|
||||
++value;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool operator!=(const vector &rhs) const { return !(*this == rhs); }
|
||||
|
||||
vector &operator=(const vector &other) {
|
||||
if (this != &other) {
|
||||
if (other.size_ > capacity_) {
|
||||
// Calling reserve would move construct and destroy all current contents, so just clear them before calling
|
||||
// PushBackFrom (which does a reserve vs. the now empty this)
|
||||
clear();
|
||||
PushBackFrom(other);
|
||||
} else {
|
||||
// The copy will fit into the current allocation
|
||||
auto dest = GetWorkingStore();
|
||||
auto source = other.GetWorkingStore();
|
||||
|
||||
const auto overlap = std::min(size_, other.size_);
|
||||
// Copy assign anywhere we have objects in this
|
||||
// Note: usually cheaper than destruct/construct
|
||||
for (size_type i = 0; i < overlap; i++) {
|
||||
dest[i] = source[i];
|
||||
}
|
||||
|
||||
// Copy construct anywhere we *don't* have objects in this
|
||||
for (size_type i = overlap; i < other.size_; i++) {
|
||||
new (dest + i) value_type(source[i]);
|
||||
}
|
||||
|
||||
// Any entries in this past other_size_ must be cleaned up...
|
||||
for (size_type i = other.size_; i < size_; i++) {
|
||||
dest[i].~value_type();
|
||||
}
|
||||
size_ = other.size_;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
vector &operator=(vector &&other) {
|
||||
if (this != &other) {
|
||||
// Note: move assign doesn't require other to become empty (as does move construction)
|
||||
// so we'll leave other alone except in the large store case, while moving the object
|
||||
// *in* the vector from other
|
||||
if (other.large_store_) {
|
||||
// Moving the other large store intact is probably best, even if we have to destroy everything in this.
|
||||
clear();
|
||||
MoveLargeStore(other);
|
||||
} else if (other.size_ > capacity_) {
|
||||
// If we'd have to reallocate, just clean up minimally and copy normally
|
||||
clear();
|
||||
PushBackFrom(std::move(other));
|
||||
} else {
|
||||
// The copy will fit into the current allocation
|
||||
auto dest = GetWorkingStore();
|
||||
auto source = other.GetWorkingStore();
|
||||
|
||||
const auto overlap = std::min(size_, other.size_);
|
||||
|
||||
// Move assign where we have objects in this
|
||||
// Note: usually cheaper than destruct/construct
|
||||
for (size_type i = 0; i < overlap; i++) {
|
||||
dest[i] = std::move(source[i]);
|
||||
}
|
||||
|
||||
// Move construct where we *don't* have objects in this
|
||||
for (size_type i = overlap; i < other.size_; i++) {
|
||||
new (dest + i) value_type(std::move(source[i]));
|
||||
}
|
||||
|
||||
// Any entries in this past other_size_ must be cleaned up...
|
||||
for (size_type i = other.size_; i < size_; i++) {
|
||||
dest[i].~value_type();
|
||||
}
|
||||
size_ = other.size_;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
reference operator[](size_type pos) {
|
||||
assert(pos < size_);
|
||||
return GetWorkingStore()[pos];
|
||||
}
|
||||
const_reference operator[](size_type pos) const {
|
||||
assert(pos < size_);
|
||||
return GetWorkingStore()[pos];
|
||||
}
|
||||
|
||||
// Like std::vector:: calling front or back on an empty container causes undefined behavior
|
||||
reference front() {
|
||||
assert(size_ > 0);
|
||||
return GetWorkingStore()[0];
|
||||
}
|
||||
const_reference front() const {
|
||||
assert(size_ > 0);
|
||||
return GetWorkingStore()[0];
|
||||
}
|
||||
reference back() {
|
||||
assert(size_ > 0);
|
||||
return GetWorkingStore()[size_ - 1];
|
||||
}
|
||||
const_reference back() const {
|
||||
assert(size_ > 0);
|
||||
return GetWorkingStore()[size_ - 1];
|
||||
}
|
||||
|
||||
bool empty() const { return size_ == 0; }
|
||||
|
||||
template <class... Args>
|
||||
void emplace_back(Args &&...args) {
|
||||
assert(size_ < kMaxCapacity);
|
||||
reserve(size_ + 1);
|
||||
new (GetWorkingStore() + size_) value_type(args...);
|
||||
size_++;
|
||||
}
|
||||
|
||||
// Note: probably should update this to reflect C++23 ranges
|
||||
template <typename Container>
|
||||
void PushBackFrom(const Container &from) {
|
||||
assert(from.size() <= kMaxCapacity);
|
||||
assert(size_ <= kMaxCapacity - from.size());
|
||||
const size_type new_size = size_ + static_cast<size_type>(from.size());
|
||||
reserve(new_size);
|
||||
|
||||
auto dest = GetWorkingStore() + size_;
|
||||
for (const auto &element : from) {
|
||||
new (dest) value_type(element);
|
||||
++dest;
|
||||
}
|
||||
size_ = new_size;
|
||||
}
|
||||
|
||||
template <typename Container>
|
||||
void PushBackFrom(Container &&from) {
|
||||
assert(from.size() < kMaxCapacity);
|
||||
const size_type new_size = size_ + static_cast<size_type>(from.size());
|
||||
reserve(new_size);
|
||||
|
||||
auto dest = GetWorkingStore() + size_;
|
||||
for (auto &element : from) {
|
||||
new (dest) value_type(std::move(element));
|
||||
++dest;
|
||||
}
|
||||
size_ = new_size;
|
||||
}
|
||||
|
||||
void reserve(size_type new_cap) {
|
||||
// Since this can't shrink, if we're growing we're newing
|
||||
if (new_cap > capacity_) {
|
||||
assert(capacity_ >= kSmallCapacity);
|
||||
auto new_store = std::unique_ptr<BackingStore[]>(new BackingStore[new_cap]);
|
||||
auto working_store = GetWorkingStore();
|
||||
for (size_type i = 0; i < size_; i++) {
|
||||
new (new_store[i].data) value_type(std::move(working_store[i]));
|
||||
working_store[i].~value_type();
|
||||
}
|
||||
large_store_ = std::move(new_store);
|
||||
assert(new_cap > kSmallCapacity);
|
||||
capacity_ = new_cap;
|
||||
}
|
||||
UpdateWorkingStore();
|
||||
// No shrink here.
|
||||
}
|
||||
|
||||
void clear() {
|
||||
// Keep clear minimal to optimize reset functions for enduring objects
|
||||
// more work is deferred until destruction (freeing of large_store for example)
|
||||
// and we intentionally *aren't* shrinking. Callers that desire shrink semantics
|
||||
// can call shrink_to_fit.
|
||||
auto working_store = GetWorkingStore();
|
||||
for (size_type i = 0; i < size_; i++) {
|
||||
working_store[i].~value_type();
|
||||
}
|
||||
size_ = 0;
|
||||
}
|
||||
|
||||
void resize(size_type count) {
|
||||
struct ValueInitTag { // tag to request value-initialization
|
||||
explicit ValueInitTag() = default;
|
||||
};
|
||||
Resize(count, ValueInitTag{});
|
||||
}
|
||||
|
||||
void resize(size_type count, const value_type &value) { Resize(count, value); }
|
||||
|
||||
void shrink_to_fit() {
|
||||
if (size_ == 0) {
|
||||
// shrink resets to small when empty
|
||||
capacity_ = kSmallCapacity;
|
||||
large_store_.reset();
|
||||
UpdateWorkingStore();
|
||||
} else if ((capacity_ > kSmallCapacity) && (capacity_ > size_)) {
|
||||
auto source = GetWorkingStore();
|
||||
// Keep the source from disappearing until the end of the function
|
||||
auto old_store = std::unique_ptr<BackingStore[]>(std::move(large_store_));
|
||||
assert(!large_store_);
|
||||
if (size_ < kSmallCapacity) {
|
||||
capacity_ = kSmallCapacity;
|
||||
} else {
|
||||
large_store_ = std::unique_ptr<BackingStore[]>(new BackingStore[size_]);
|
||||
capacity_ = size_;
|
||||
}
|
||||
UpdateWorkingStore();
|
||||
auto dest = GetWorkingStore();
|
||||
for (size_type i = 0; i < size_; i++) {
|
||||
dest[i] = std::move(source[i]);
|
||||
source[i].~value_type();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline iterator begin() { return GetWorkingStore(); }
|
||||
inline const_iterator cbegin() const { return GetWorkingStore(); }
|
||||
inline const_iterator begin() const { return GetWorkingStore(); }
|
||||
|
||||
inline iterator end() { return GetWorkingStore() + size_; }
|
||||
inline const_iterator cend() const { return GetWorkingStore() + size_; }
|
||||
inline const_iterator end() const { return GetWorkingStore() + size_; }
|
||||
inline size_type size() const { return size_; }
|
||||
auto capacity() const { return capacity_; }
|
||||
|
||||
inline pointer data() { return GetWorkingStore(); }
|
||||
inline const_pointer data() const { return GetWorkingStore(); }
|
||||
|
||||
protected:
|
||||
inline const_pointer ComputeWorkingStore() const {
|
||||
assert(large_store_ || (capacity_ == kSmallCapacity));
|
||||
|
||||
const BackingStore *store = large_store_ ? large_store_.get() : small_store_;
|
||||
return &store->object;
|
||||
}
|
||||
inline pointer ComputeWorkingStore() {
|
||||
assert(large_store_ || (capacity_ == kSmallCapacity));
|
||||
|
||||
BackingStore *store = large_store_ ? large_store_.get() : small_store_;
|
||||
return &store->object;
|
||||
}
|
||||
|
||||
void UpdateWorkingStore() { working_store_ = ComputeWorkingStore(); }
|
||||
|
||||
inline const_pointer GetWorkingStore() const {
|
||||
DbgWorkingStoreCheck();
|
||||
return working_store_;
|
||||
}
|
||||
inline pointer GetWorkingStore() {
|
||||
DbgWorkingStoreCheck();
|
||||
return working_store_;
|
||||
}
|
||||
|
||||
inline pointer GetSmallStore() { return &small_store_->object; }
|
||||
|
||||
union BackingStore {
|
||||
BackingStore() {}
|
||||
~BackingStore() {}
|
||||
|
||||
uint8_t data[sizeof(value_type)];
|
||||
value_type object;
|
||||
};
|
||||
size_type size_;
|
||||
size_type capacity_;
|
||||
BackingStore small_store_[N];
|
||||
std::unique_ptr<BackingStore[]> large_store_;
|
||||
value_type *working_store_;
|
||||
|
||||
#ifndef NDEBUG
|
||||
void DbgWorkingStoreCheck() const { assert(ComputeWorkingStore() == working_store_); }
|
||||
#else
|
||||
void DbgWorkingStoreCheck() const {}
|
||||
#endif
|
||||
|
||||
private:
|
||||
void MoveLargeStore(vector &other) {
|
||||
assert(other.large_store_);
|
||||
assert(other.capacity_ > kSmallCapacity);
|
||||
// In move operations, from a small vector with a large store, we can move from it
|
||||
large_store_ = std::move(other.large_store_);
|
||||
capacity_ = other.capacity_;
|
||||
size_ = other.size_;
|
||||
UpdateWorkingStore();
|
||||
|
||||
// We've stolen other's large store, must leave it in a valid state
|
||||
other.size_ = 0;
|
||||
other.capacity_ = kSmallCapacity;
|
||||
other.UpdateWorkingStore();
|
||||
}
|
||||
|
||||
template <typename T2>
|
||||
void Resize(size_type new_size, const T2 &value) {
|
||||
if (new_size < size_) {
|
||||
auto working_store = GetWorkingStore();
|
||||
for (size_type i = new_size; i < size_; i++) {
|
||||
working_store[i].~value_type();
|
||||
}
|
||||
size_ = new_size;
|
||||
} else if (new_size > size_) {
|
||||
reserve(new_size);
|
||||
// if T2 != T and T is not DefaultInsertable, new values will be undefined
|
||||
if constexpr (std::is_same_v<T2, T> || std::is_default_constructible_v<T>) {
|
||||
for (size_type i = size_; i < new_size; ++i) {
|
||||
if constexpr (std::is_same_v<T2, T>) {
|
||||
emplace_back(value_type(value));
|
||||
} else if constexpr (std::is_default_constructible_v<T>) {
|
||||
emplace_back(value_type());
|
||||
}
|
||||
}
|
||||
assert(size() == new_size);
|
||||
} else {
|
||||
size_ = new_size;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// This is a wrapper around unordered_map that optimizes for the common case
|
||||
// of only containing a small number of elements. The first N elements are stored
|
||||
// inline in the object and don't require hashing or memory (de)allocation.
|
||||
|
||||
template <typename Key, typename value_type, typename inner_container_type, typename value_type_helper, int N>
|
||||
class container_base {
|
||||
protected:
|
||||
bool small_data_allocated[N];
|
||||
value_type small_data[N];
|
||||
|
||||
inner_container_type inner_cont;
|
||||
|
||||
value_type_helper helper;
|
||||
|
||||
public:
|
||||
container_base() {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
small_data_allocated[i] = false;
|
||||
}
|
||||
}
|
||||
|
||||
class iterator {
|
||||
typedef typename inner_container_type::iterator inner_iterator;
|
||||
friend class container_base<Key, value_type, inner_container_type, value_type_helper, N>;
|
||||
|
||||
container_base<Key, value_type, inner_container_type, value_type_helper, N> *parent;
|
||||
int index;
|
||||
inner_iterator it;
|
||||
|
||||
public:
|
||||
iterator() {}
|
||||
|
||||
iterator operator++() {
|
||||
if (index < N) {
|
||||
index++;
|
||||
while (index < N && !parent->small_data_allocated[index]) {
|
||||
index++;
|
||||
}
|
||||
if (index < N) {
|
||||
return *this;
|
||||
}
|
||||
it = parent->inner_cont.begin();
|
||||
return *this;
|
||||
}
|
||||
++it;
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const iterator &other) const {
|
||||
if ((index < N) != (other.index < N)) {
|
||||
return false;
|
||||
}
|
||||
if (index < N) {
|
||||
return (index == other.index);
|
||||
}
|
||||
return it == other.it;
|
||||
}
|
||||
|
||||
bool operator!=(const iterator &other) const { return !(*this == other); }
|
||||
|
||||
value_type &operator*() const {
|
||||
if (index < N) {
|
||||
return parent->small_data[index];
|
||||
}
|
||||
return *it;
|
||||
}
|
||||
value_type *operator->() const {
|
||||
if (index < N) {
|
||||
return &parent->small_data[index];
|
||||
}
|
||||
return &*it;
|
||||
}
|
||||
};
|
||||
|
||||
class const_iterator {
|
||||
typedef typename inner_container_type::const_iterator inner_iterator;
|
||||
friend class container_base<Key, value_type, inner_container_type, value_type_helper, N>;
|
||||
|
||||
const container_base<Key, value_type, inner_container_type, value_type_helper, N> *parent;
|
||||
int index;
|
||||
inner_iterator it;
|
||||
|
||||
public:
|
||||
const_iterator() {}
|
||||
|
||||
const_iterator operator++() {
|
||||
if (index < N) {
|
||||
index++;
|
||||
while (index < N && !parent->small_data_allocated[index]) {
|
||||
index++;
|
||||
}
|
||||
if (index < N) {
|
||||
return *this;
|
||||
}
|
||||
it = parent->inner_cont.begin();
|
||||
return *this;
|
||||
}
|
||||
++it;
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const const_iterator &other) const {
|
||||
if ((index < N) != (other.index < N)) {
|
||||
return false;
|
||||
}
|
||||
if (index < N) {
|
||||
return (index == other.index);
|
||||
}
|
||||
return it == other.it;
|
||||
}
|
||||
|
||||
bool operator!=(const const_iterator &other) const { return !(*this == other); }
|
||||
|
||||
const value_type &operator*() const {
|
||||
if (index < N) {
|
||||
return parent->small_data[index];
|
||||
}
|
||||
return *it;
|
||||
}
|
||||
const value_type *operator->() const {
|
||||
if (index < N) {
|
||||
return &parent->small_data[index];
|
||||
}
|
||||
return &*it;
|
||||
}
|
||||
};
|
||||
|
||||
iterator begin() {
|
||||
iterator it;
|
||||
it.parent = this;
|
||||
// If index 0 is allocated, return it, otherwise use operator++ to find the first
|
||||
// allocated element.
|
||||
it.index = 0;
|
||||
if (small_data_allocated[0]) {
|
||||
return it;
|
||||
}
|
||||
++it;
|
||||
return it;
|
||||
}
|
||||
|
||||
iterator end() {
|
||||
iterator it;
|
||||
it.parent = this;
|
||||
it.index = N;
|
||||
it.it = inner_cont.end();
|
||||
return it;
|
||||
}
|
||||
|
||||
const_iterator begin() const {
|
||||
const_iterator it;
|
||||
it.parent = this;
|
||||
// If index 0 is allocated, return it, otherwise use operator++ to find the first
|
||||
// allocated element.
|
||||
it.index = 0;
|
||||
if (small_data_allocated[0]) {
|
||||
return it;
|
||||
}
|
||||
++it;
|
||||
return it;
|
||||
}
|
||||
|
||||
const_iterator end() const {
|
||||
const_iterator it;
|
||||
it.parent = this;
|
||||
it.index = N;
|
||||
it.it = inner_cont.end();
|
||||
return it;
|
||||
}
|
||||
|
||||
bool contains(const Key &key) const {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
if (small_data_allocated[i] && helper.compare_equal(small_data[i], key)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
// check size() first to avoid hashing key unnecessarily.
|
||||
if (inner_cont.size() == 0) {
|
||||
return false;
|
||||
}
|
||||
return inner_cont.find(key) != inner_cont.end();
|
||||
}
|
||||
|
||||
typename inner_container_type::size_type count(const Key &key) const { return contains(key) ? 1 : 0; }
|
||||
|
||||
std::pair<iterator, bool> insert(const value_type &value) {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
if (small_data_allocated[i] && helper.compare_equal(small_data[i], value)) {
|
||||
iterator it;
|
||||
it.parent = this;
|
||||
it.index = i;
|
||||
return std::make_pair(it, false);
|
||||
}
|
||||
}
|
||||
// check size() first to avoid hashing key unnecessarily.
|
||||
auto iter = inner_cont.size() > 0 ? inner_cont.find(helper.get_key(value)) : inner_cont.end();
|
||||
if (iter != inner_cont.end()) {
|
||||
iterator it;
|
||||
it.parent = this;
|
||||
it.index = N;
|
||||
it.it = iter;
|
||||
return std::make_pair(it, false);
|
||||
} else {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
if (!small_data_allocated[i]) {
|
||||
small_data_allocated[i] = true;
|
||||
helper.assign(small_data[i], value);
|
||||
iterator it;
|
||||
it.parent = this;
|
||||
it.index = i;
|
||||
return std::make_pair(it, true);
|
||||
}
|
||||
}
|
||||
iter = inner_cont.insert(value).first;
|
||||
iterator it;
|
||||
it.parent = this;
|
||||
it.index = N;
|
||||
it.it = iter;
|
||||
return std::make_pair(it, true);
|
||||
}
|
||||
}
|
||||
|
||||
typename inner_container_type::size_type erase(const Key &key) {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
if (small_data_allocated[i] && helper.compare_equal(small_data[i], key)) {
|
||||
small_data_allocated[i] = false;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return inner_cont.erase(key);
|
||||
}
|
||||
|
||||
typename inner_container_type::size_type size() const {
|
||||
auto size = inner_cont.size();
|
||||
for (int i = 0; i < N; ++i) {
|
||||
if (small_data_allocated[i]) {
|
||||
size++;
|
||||
}
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
bool empty() const {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
if (small_data_allocated[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return inner_cont.size() == 0;
|
||||
}
|
||||
|
||||
void clear() {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
small_data_allocated[i] = false;
|
||||
}
|
||||
inner_cont.clear();
|
||||
}
|
||||
};
|
||||
|
||||
// Helper function objects to compare/assign/get keys in small_unordered_set/map.
|
||||
// This helps to abstract away whether value_type is a Key or a pair<Key, T>.
|
||||
template <typename MapType>
|
||||
class value_type_helper_map {
|
||||
using PairType = typename MapType::value_type;
|
||||
using Key = typename std::remove_const<typename PairType::first_type>::type;
|
||||
|
||||
public:
|
||||
bool compare_equal(const PairType &lhs, const Key &rhs) const { return lhs.first == rhs; }
|
||||
bool compare_equal(const PairType &lhs, const PairType &rhs) const { return lhs.first == rhs.first; }
|
||||
|
||||
void assign(PairType &lhs, const PairType &rhs) const {
|
||||
// While the const_cast may be unsatisfactory, we are using small_data as
|
||||
// stand-in for placement new and a small-block allocator, so the const_cast
|
||||
// is minimal, contained, valid, and allows operators * and -> to avoid copies
|
||||
const_cast<Key &>(lhs.first) = rhs.first;
|
||||
lhs.second = rhs.second;
|
||||
}
|
||||
|
||||
Key get_key(const PairType &value) const { return value.first; }
|
||||
};
|
||||
|
||||
template <typename Key>
|
||||
class value_type_helper_set {
|
||||
public:
|
||||
bool compare_equal(const Key &lhs, const Key &rhs) const { return lhs == rhs; }
|
||||
|
||||
void assign(Key &lhs, const Key &rhs) const { lhs = rhs; }
|
||||
|
||||
Key get_key(const Key &value) const { return value; }
|
||||
};
|
||||
|
||||
template <typename Key, typename T, int N = 1, typename Map = std::unordered_map<Key, T>>
|
||||
class unordered_map : public container_base<Key, typename Map::value_type, Map, value_type_helper_map<Map>, N> {
|
||||
public:
|
||||
T &operator[](const Key &key) {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
if (this->small_data_allocated[i] && this->helper.compare_equal(this->small_data[i], key)) {
|
||||
return this->small_data[i].second;
|
||||
}
|
||||
}
|
||||
auto iter = this->inner_cont.find(key);
|
||||
if (iter != this->inner_cont.end()) {
|
||||
return iter->second;
|
||||
} else {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
if (!this->small_data_allocated[i]) {
|
||||
this->small_data_allocated[i] = true;
|
||||
this->helper.assign(this->small_data[i], {key, T()});
|
||||
|
||||
return this->small_data[i].second;
|
||||
}
|
||||
}
|
||||
return this->inner_cont[key];
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Key, int N = 1, typename Set = std::unordered_set<Key>>
|
||||
class unordered_set : public container_base<Key, Key, Set, value_type_helper_set<Key>, N> {};
|
||||
|
||||
} // namespace small
|
||||
} // namespace vku
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,23 +1,9 @@
|
||||
//
|
||||
// File: vk_icd.h
|
||||
//
|
||||
/*
|
||||
* 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.
|
||||
* Copyright 2015-2023 The Khronos Group Inc.
|
||||
* Copyright 2015-2023 Valve Corporation
|
||||
* Copyright 2015-2023 LunarG, Inc.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
|
||||
@@ -1,23 +1,9 @@
|
||||
//
|
||||
// File: vk_layer.h
|
||||
//
|
||||
/*
|
||||
* 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.
|
||||
* Copyright 2015-2023 The Khronos Group Inc.
|
||||
* Copyright 2015-2023 Valve Corporation
|
||||
* Copyright 2015-2023 LunarG, Inc.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
// File: vk_platform.h
|
||||
//
|
||||
/*
|
||||
** Copyright 2014-2023 The Khronos Group Inc.
|
||||
** Copyright 2014-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
+5540
-895
File diff suppressed because it is too large
Load Diff
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_ANDROID_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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
|
||||
@@ -42,6 +43,7 @@ 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
|
||||
@@ -118,6 +120,32 @@ 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
|
||||
|
||||
+108
-429
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_BETA_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
@@ -50,444 +51,122 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
|
||||
|
||||
|
||||
|
||||
#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 {
|
||||
// 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 {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
uint64_t averageBitrate;
|
||||
uint64_t maxBitrate;
|
||||
uint32_t frameRateNumerator;
|
||||
uint32_t frameRateDenominator;
|
||||
uint32_t virtualBufferSizeInMs;
|
||||
uint32_t initialVirtualBufferSizeInMs;
|
||||
} VkVideoEncodeRateControlLayerInfoKHR;
|
||||
void* pNext;
|
||||
VkBool32 shaderEnqueue;
|
||||
} VkPhysicalDeviceShaderEnqueueFeaturesAMDX;
|
||||
|
||||
typedef struct VkVideoEncodeRateControlInfoKHR {
|
||||
VkStructureType sType;
|
||||
const void* pNext;
|
||||
VkVideoEncodeRateControlFlagsKHR flags;
|
||||
VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
|
||||
uint32_t layerCount;
|
||||
const VkVideoEncodeRateControlLayerInfoKHR* pLayers;
|
||||
} VkVideoEncodeRateControlInfoKHR;
|
||||
typedef struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
|
||||
VkStructureType sType;
|
||||
void* pNext;
|
||||
uint32_t maxExecutionGraphDepth;
|
||||
uint32_t maxExecutionGraphShaderOutputNodes;
|
||||
uint32_t maxExecutionGraphShaderPayloadSize;
|
||||
uint32_t maxExecutionGraphShaderPayloadCount;
|
||||
uint32_t executionGraphDispatchAddressAlignment;
|
||||
} VkPhysicalDeviceShaderEnqueuePropertiesAMDX;
|
||||
|
||||
typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
|
||||
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);
|
||||
|
||||
#ifndef VK_NO_PROTOTYPES
|
||||
VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
|
||||
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(
|
||||
VkCommandBuffer commandBuffer,
|
||||
const VkVideoEncodeInfoKHR* pEncodeInfo);
|
||||
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);
|
||||
#endif
|
||||
|
||||
|
||||
#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;
|
||||
|
||||
|
||||
|
||||
// VK_NV_displacement_micromap is a preprocessor guard. Do not pass it to API calls.
|
||||
#define VK_NV_displacement_micromap 1
|
||||
#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 1
|
||||
#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 2
|
||||
#define VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME "VK_NV_displacement_micromap"
|
||||
|
||||
typedef enum VkDisplacementMicromapFormatNV {
|
||||
|
||||
+3452
-271
File diff suppressed because it is too large
Load Diff
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_DIRECTFB_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
|
||||
+2402
-1379
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,4 +1,4 @@
|
||||
// Copyright 2015-2023 The Khronos Group Inc.
|
||||
// Copyright 2015-2024 The Khronos Group Inc.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
//
|
||||
@@ -12,6 +12,7 @@
|
||||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
|
||||
//=====================
|
||||
//=== Format Traits ===
|
||||
//=====================
|
||||
@@ -361,7 +362,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 8;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 8;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 8;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 2;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
|
||||
|
||||
default: VULKAN_HPP_ASSERT( false ); return 0;
|
||||
}
|
||||
@@ -618,7 +621,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return "PVRTC1_4BPP";
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return "PVRTC2_2BPP";
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return "PVRTC2_4BPP";
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return "32-bit";
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return "32-bit";
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return "16-bit";
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return "8-bit alpha";
|
||||
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
@@ -1592,7 +1597,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
case 0: return 10;
|
||||
case 1: return 11;
|
||||
case 2: return 10;
|
||||
case 2: return 11;
|
||||
default: VULKAN_HPP_ASSERT( false ); return 0;
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eE5B9G9R9UfloatPack32:
|
||||
@@ -2000,13 +2005,28 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case 3: return 4;
|
||||
default: VULKAN_HPP_ASSERT( false ); return 0;
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return 16;
|
||||
case 1: return 16;
|
||||
default: VULKAN_HPP_ASSERT( false ); return 0;
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return 1;
|
||||
case 1: return 5;
|
||||
case 2: return 5;
|
||||
case 3: return 5;
|
||||
default: VULKAN_HPP_ASSERT( false ); return 0;
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return 8;
|
||||
default: VULKAN_HPP_ASSERT( false ); return 0;
|
||||
}
|
||||
|
||||
default: return 0;
|
||||
}
|
||||
@@ -2263,7 +2283,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 2;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 2;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 4;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
|
||||
|
||||
default: return 0;
|
||||
}
|
||||
@@ -2328,8 +2350,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "B";
|
||||
case 1: return "R";
|
||||
case 2: return "G";
|
||||
case 1: return "G";
|
||||
case 2: return "R";
|
||||
case 3: return "A";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
@@ -3164,21 +3186,21 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sint:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sfloat:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64B64Uint:
|
||||
@@ -4277,13 +4299,28 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case 3: return "A";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "A";
|
||||
case 1: return "B";
|
||||
case 2: return "G";
|
||||
case 3: return "R";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "A";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
|
||||
default: return "";
|
||||
}
|
||||
@@ -5392,7 +5429,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc4SnormBlock:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "SRGB";
|
||||
case 0: return "SNORM";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc5UnormBlock:
|
||||
@@ -5405,8 +5442,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc5SnormBlock:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 0: return "SNORM";
|
||||
case 1: return "SNORM";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc6HUfloatBlock:
|
||||
@@ -6297,11 +6334,26 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case 3: return "SRGB";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV:
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "SINT";
|
||||
case 1: return "SINT";
|
||||
case 0: return "SFIXED5";
|
||||
case 1: return "SFIXED5";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "UNORM";
|
||||
case 1: return "UNORM";
|
||||
case 2: return "UNORM";
|
||||
case 3: return "UNORM";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "UNORM";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
|
||||
@@ -6744,6 +6796,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: return 16;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA4R4G4B4UnormPack16: return 16;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA4B4G4R4UnormPack16: return 16;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 16;
|
||||
|
||||
default: return 0;
|
||||
}
|
||||
@@ -7604,7 +7657,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16S105NV: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 1;
|
||||
case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
|
||||
|
||||
default: VULKAN_HPP_ASSERT( false ); return 0;
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_FUCHSIA_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
@@ -41,6 +42,7 @@ 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"
|
||||
@@ -81,6 +83,7 @@ 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"
|
||||
@@ -115,6 +118,7 @@ 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
|
||||
|
||||
+7913
-2543
File diff suppressed because it is too large
Load Diff
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_GGP_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
@@ -41,6 +42,7 @@ 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"
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
+3297
-512
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,319 @@
|
||||
// Copyright 2015-2024 The Khronos Group Inc.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
//
|
||||
|
||||
// This header is generated from the Khronos Vulkan XML API Registry.
|
||||
|
||||
#ifndef VULKAN_HPP_MACROS_HPP
|
||||
#define VULKAN_HPP_MACROS_HPP
|
||||
|
||||
#if defined( _MSVC_LANG )
|
||||
# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
|
||||
#else
|
||||
# define VULKAN_HPP_CPLUSPLUS __cplusplus
|
||||
#endif
|
||||
|
||||
#if 202002L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 23
|
||||
#elif 201703L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 20
|
||||
#elif 201402L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 17
|
||||
#elif 201103L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 14
|
||||
#elif 199711L < VULKAN_HPP_CPLUSPLUS
|
||||
# define VULKAN_HPP_CPP_VERSION 11
|
||||
#else
|
||||
# error "vulkan.hpp needs at least c++ standard version 11"
|
||||
#endif
|
||||
|
||||
// include headers holding feature-test macros
|
||||
#if 20 <= VULKAN_HPP_CPP_VERSION
|
||||
# include <version>
|
||||
#else
|
||||
# include <ciso646>
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
|
||||
# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||
# define VULKAN_HPP_NO_SMART_HANDLE
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
|
||||
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
|
||||
# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
|
||||
# endif
|
||||
# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
|
||||
# define VULKAN_HPP_NO_UNION_CONSTRUCTORS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_NO_SETTERS )
|
||||
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
|
||||
# define VULKAN_HPP_NO_STRUCT_SETTERS
|
||||
# endif
|
||||
# if !defined( VULKAN_HPP_NO_UNION_SETTERS )
|
||||
# define VULKAN_HPP_NO_UNION_SETTERS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_ASSERT )
|
||||
# define VULKAN_HPP_ASSERT assert
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
|
||||
# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_STATIC_ASSERT )
|
||||
# define VULKAN_HPP_STATIC_ASSERT static_assert
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
|
||||
# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
|
||||
#endif
|
||||
|
||||
#if !defined( __has_include )
|
||||
# define __has_include( x ) false
|
||||
#endif
|
||||
|
||||
#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
|
||||
# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
|
||||
#endif
|
||||
|
||||
#if ( 201803 <= __cpp_lib_span )
|
||||
# define VULKAN_HPP_SUPPORT_SPAN
|
||||
#endif
|
||||
|
||||
#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_STD_MODULE ) && defined( VULKAN_HPP_ENABLE_STD_MODULE )
|
||||
# define VULKAN_HPP_STD_MODULE std.compat
|
||||
#endif
|
||||
|
||||
#ifndef VK_USE_64_BIT_PTR_DEFINES
|
||||
# if defined( __LP64__ ) || defined( _WIN64 ) || ( defined( __x86_64__ ) && !defined( __ILP32__ ) ) || defined( _M_X64 ) || defined( __ia64 ) || \
|
||||
defined( _M_IA64 ) || defined( __aarch64__ ) || defined( __powerpc64__ ) || ( defined( __riscv ) && __riscv_xlen == 64 )
|
||||
# define VK_USE_64_BIT_PTR_DEFINES 1
|
||||
# else
|
||||
# define VK_USE_64_BIT_PTR_DEFINES 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
|
||||
// To enable this feature on 32-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 1
|
||||
// To disable this feature on 64-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 0
|
||||
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
||||
# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
|
||||
# define VULKAN_HPP_TYPESAFE_CONVERSION 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( __GNUC__ )
|
||||
# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
|
||||
# if defined( __clang__ )
|
||||
# if __has_feature( cxx_unrestricted_unions )
|
||||
# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
|
||||
# endif
|
||||
# elif defined( __GNUC__ )
|
||||
# if 40600 <= GCC_VERSION
|
||||
# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
|
||||
# endif
|
||||
# elif defined( _MSC_VER )
|
||||
# if 1900 <= _MSC_VER
|
||||
# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_INLINE )
|
||||
# if defined( __clang__ )
|
||||
# if __has_attribute( always_inline )
|
||||
# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
|
||||
# else
|
||||
# define VULKAN_HPP_INLINE inline
|
||||
# endif
|
||||
# elif defined( __GNUC__ )
|
||||
# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
|
||||
# elif defined( _MSC_VER )
|
||||
# define VULKAN_HPP_INLINE inline
|
||||
# else
|
||||
# define VULKAN_HPP_INLINE inline
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
|
||||
# define VULKAN_HPP_TYPESAFE_EXPLICIT
|
||||
#else
|
||||
# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
|
||||
#endif
|
||||
|
||||
#if defined( __cpp_constexpr )
|
||||
# define VULKAN_HPP_CONSTEXPR constexpr
|
||||
# if 201304 <= __cpp_constexpr
|
||||
# define VULKAN_HPP_CONSTEXPR_14 constexpr
|
||||
# else
|
||||
# define VULKAN_HPP_CONSTEXPR_14
|
||||
# endif
|
||||
# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) )
|
||||
# define VULKAN_HPP_CONSTEXPR_20 constexpr
|
||||
# else
|
||||
# define VULKAN_HPP_CONSTEXPR_20
|
||||
# endif
|
||||
# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
|
||||
#else
|
||||
# define VULKAN_HPP_CONSTEXPR
|
||||
# define VULKAN_HPP_CONSTEXPR_14
|
||||
# define VULKAN_HPP_CONST_OR_CONSTEXPR const
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_CONSTEXPR_INLINE )
|
||||
# if 201606L <= __cpp_inline_variables
|
||||
# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR inline
|
||||
# else
|
||||
# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_NOEXCEPT )
|
||||
# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
|
||||
# define VULKAN_HPP_NOEXCEPT
|
||||
# else
|
||||
# define VULKAN_HPP_NOEXCEPT noexcept
|
||||
# define VULKAN_HPP_HAS_NOEXCEPT 1
|
||||
# if defined( VULKAN_HPP_NO_EXCEPTIONS )
|
||||
# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
|
||||
# else
|
||||
# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if 14 <= VULKAN_HPP_CPP_VERSION
|
||||
# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
|
||||
#else
|
||||
# define VULKAN_HPP_DEPRECATED( msg )
|
||||
#endif
|
||||
|
||||
#if 17 <= VULKAN_HPP_CPP_VERSION
|
||||
# define VULKAN_HPP_DEPRECATED_17( msg ) [[deprecated( msg )]]
|
||||
#else
|
||||
# define VULKAN_HPP_DEPRECATED_17( msg )
|
||||
#endif
|
||||
|
||||
#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
|
||||
# define VULKAN_HPP_NODISCARD [[nodiscard]]
|
||||
# if defined( VULKAN_HPP_NO_EXCEPTIONS )
|
||||
# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
|
||||
# else
|
||||
# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
|
||||
# endif
|
||||
#else
|
||||
# define VULKAN_HPP_NODISCARD
|
||||
# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_NAMESPACE )
|
||||
# define VULKAN_HPP_NAMESPACE vk
|
||||
#endif
|
||||
|
||||
#define VULKAN_HPP_STRINGIFY2( text ) #text
|
||||
#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
|
||||
#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
|
||||
|
||||
#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
|
||||
# if defined( VK_NO_PROTOTYPES )
|
||||
# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
|
||||
# else
|
||||
# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_STORAGE_API )
|
||||
# if defined( VULKAN_HPP_STORAGE_SHARED )
|
||||
# if defined( _MSC_VER )
|
||||
# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
|
||||
# define VULKAN_HPP_STORAGE_API __declspec( dllexport )
|
||||
# else
|
||||
# define VULKAN_HPP_STORAGE_API __declspec( dllimport )
|
||||
# endif
|
||||
# elif defined( __clang__ ) || defined( __GNUC__ )
|
||||
# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
|
||||
# define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
|
||||
# else
|
||||
# define VULKAN_HPP_STORAGE_API
|
||||
# endif
|
||||
# else
|
||||
# define VULKAN_HPP_STORAGE_API
|
||||
# pragma warning Unknown import / export semantics
|
||||
# endif
|
||||
# else
|
||||
# define VULKAN_HPP_STORAGE_API
|
||||
# endif
|
||||
#endif
|
||||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
class DispatchLoaderDynamic;
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
|
||||
# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \
|
||||
namespace VULKAN_HPP_NAMESPACE \
|
||||
{ \
|
||||
VULKAN_HPP_STORAGE_API ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
|
||||
}
|
||||
|
||||
namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
extern VULKAN_HPP_STORAGE_API VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic;
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
# else
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
|
||||
# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
|
||||
# else
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
|
||||
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
|
||||
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
|
||||
#else
|
||||
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
|
||||
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
|
||||
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_EXPECTED ) && ( 23 <= VULKAN_HPP_CPP_VERSION ) && defined( __cpp_lib_expected )
|
||||
# if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
|
||||
# include <expected>
|
||||
# endif
|
||||
# define VULKAN_HPP_EXPECTED std::expected
|
||||
# define VULKAN_HPP_UNEXPECTED std::unexpected
|
||||
#endif
|
||||
|
||||
#if !defined( VULKAN_HPP_RAII_NAMESPACE )
|
||||
# define VULKAN_HPP_RAII_NAMESPACE raii
|
||||
#endif
|
||||
|
||||
#if defined( VULKAN_HPP_NO_EXCEPTIONS ) && defined( VULKAN_HPP_EXPECTED )
|
||||
# define VULKAN_HPP_RAII_NO_EXCEPTIONS
|
||||
# define VULKAN_HPP_RAII_CREATE_NOEXCEPT noexcept
|
||||
#else
|
||||
# define VULKAN_HPP_RAII_CREATE_NOEXCEPT
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_IOS_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_MACOS_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_METAL_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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;
|
||||
@@ -47,31 +48,32 @@ 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;
|
||||
typedef id<MTLDevice> MTLDevice_id;
|
||||
typedef __unsafe_unretained id<MTLDevice> MTLDevice_id;
|
||||
#else
|
||||
typedef void* MTLDevice_id;
|
||||
#endif
|
||||
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLCommandQueue;
|
||||
typedef id<MTLCommandQueue> MTLCommandQueue_id;
|
||||
typedef __unsafe_unretained id<MTLCommandQueue> MTLCommandQueue_id;
|
||||
#else
|
||||
typedef void* MTLCommandQueue_id;
|
||||
#endif
|
||||
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLBuffer;
|
||||
typedef id<MTLBuffer> MTLBuffer_id;
|
||||
typedef __unsafe_unretained id<MTLBuffer> MTLBuffer_id;
|
||||
#else
|
||||
typedef void* MTLBuffer_id;
|
||||
#endif
|
||||
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLTexture;
|
||||
typedef id<MTLTexture> MTLTexture_id;
|
||||
typedef __unsafe_unretained id<MTLTexture> MTLTexture_id;
|
||||
#else
|
||||
typedef void* MTLTexture_id;
|
||||
#endif
|
||||
@@ -79,12 +81,12 @@ typedef void* MTLTexture_id;
|
||||
typedef struct __IOSurface* IOSurfaceRef;
|
||||
#ifdef __OBJC__
|
||||
@protocol MTLSharedEvent;
|
||||
typedef id<MTLSharedEvent> MTLSharedEvent_id;
|
||||
typedef __unsafe_unretained id<MTLSharedEvent> MTLSharedEvent_id;
|
||||
#else
|
||||
typedef void* MTLSharedEvent_id;
|
||||
#endif
|
||||
|
||||
#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1
|
||||
#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 2
|
||||
#define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects"
|
||||
|
||||
typedef enum VkExportMetalObjectTypeFlagBitsEXT {
|
||||
|
||||
+8881
-10109
File diff suppressed because it is too large
Load Diff
+6911
-3223
File diff suppressed because it is too large
Load Diff
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_SCREEN_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
@@ -47,6 +48,59 @@ 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
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
+29478
-7910
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_VI_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_WAYLAND_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_WIN32_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
@@ -47,6 +48,7 @@ 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"
|
||||
@@ -96,6 +98,7 @@ 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"
|
||||
@@ -113,6 +116,7 @@ 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"
|
||||
@@ -165,6 +169,7 @@ 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"
|
||||
@@ -208,6 +213,7 @@ 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"
|
||||
@@ -236,6 +242,7 @@ 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"
|
||||
@@ -253,6 +260,7 @@ 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"
|
||||
@@ -309,6 +317,7 @@ 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"
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_XCB_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_XLIB_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define VULKAN_XLIB_XRANDR_H_ 1
|
||||
|
||||
/*
|
||||
** Copyright 2015-2023 The Khronos Group Inc.
|
||||
** Copyright 2015-2024 The Khronos Group Inc.
|
||||
**
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -19,6 +19,7 @@ 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"
|
||||
|
||||
Reference in New Issue
Block a user