diff options
142 files changed, 3659 insertions, 17226 deletions
diff --git a/cmds/dumpstate/Android.bp b/cmds/dumpstate/Android.bp index 4020480479..8d383f501a 100644 --- a/cmds/dumpstate/Android.bp +++ b/cmds/dumpstate/Android.bp @@ -86,6 +86,7 @@ cc_defaults { "libdumpstateaidl", "libdumpstateutil", "libdumputils", + "libhardware_legacy", "libhidlbase", "libhidltransport", "liblog", @@ -94,7 +95,6 @@ cc_defaults { srcs: [ "DumpstateSectionReporter.cpp", "DumpstateService.cpp", - "utils.cpp", ], static_libs: [ "libincidentcompanion", @@ -146,7 +146,11 @@ cc_test { ], static_libs: ["libgmock"], test_config: "dumpstate_test.xml", - data: [":dumpstate_test_fixture", "tests/testdata/**/*"] + data: [ + ":dumpstate_test_fixture", + "tests/testdata/**/*", + ], + test_suites: ["device-tests"], } cc_test { diff --git a/cmds/dumpstate/DumpstateInternal.cpp b/cmds/dumpstate/DumpstateInternal.cpp index 33e35f7274..bbc724c4c0 100644 --- a/cmds/dumpstate/DumpstateInternal.cpp +++ b/cmds/dumpstate/DumpstateInternal.cpp @@ -68,7 +68,8 @@ bool DropRootUser() { } static const std::vector<std::string> group_names{ - "log", "sdcard_r", "sdcard_rw", "mount", "inet", "net_bw_stats", "readproc", "bluetooth"}; + "log", "sdcard_r", "sdcard_rw", "mount", "inet", "net_bw_stats", + "readproc", "bluetooth", "wakelock"}; std::vector<gid_t> groups(group_names.size(), 0); for (size_t i = 0; i < group_names.size(); ++i) { grp = getgrnam(group_names[i].c_str()); @@ -116,6 +117,11 @@ bool DropRootUser() { capdata[cap_syslog_index].effective |= cap_syslog_mask; } + const uint32_t cap_block_suspend_mask = CAP_TO_MASK(CAP_BLOCK_SUSPEND); + const uint32_t cap_block_suspend_index = CAP_TO_INDEX(CAP_BLOCK_SUSPEND); + capdata[cap_block_suspend_index].permitted |= cap_block_suspend_mask; + capdata[cap_block_suspend_index].effective |= cap_block_suspend_mask; + if (capset(&capheader, &capdata[0]) != 0) { MYLOGE("capset({%#x, %#x}) failed: %s\n", capdata[0].effective, capdata[1].effective, strerror(errno)); diff --git a/cmds/dumpstate/DumpstateUtil.cpp b/cmds/dumpstate/DumpstateUtil.cpp index 97c8ae2045..4b69607156 100644 --- a/cmds/dumpstate/DumpstateUtil.cpp +++ b/cmds/dumpstate/DumpstateUtil.cpp @@ -378,34 +378,6 @@ int RunCommandToFd(int fd, const std::string& title, const std::vector<std::stri return status; } -int GetPidByName(const std::string& ps_name) { - DIR* proc_dir; - struct dirent* ps; - unsigned int pid; - std::string cmdline; - - if (!(proc_dir = opendir("/proc"))) { - MYLOGE("Can't open /proc\n"); - return -1; - } - - while ((ps = readdir(proc_dir))) { - if (!(pid = atoi(ps->d_name))) { - continue; - } - android::base::ReadFileToString("/proc/" + std::string(ps->d_name) + "/cmdline", &cmdline); - if (cmdline.find(ps_name) == std::string::npos) { - continue; - } else { - closedir(proc_dir); - return pid; - } - } - MYLOGE("can't find the pid\n"); - closedir(proc_dir); - return -1; -} - } // namespace dumpstate } // namespace os } // namespace android diff --git a/cmds/dumpstate/DumpstateUtil.h b/cmds/dumpstate/DumpstateUtil.h index d75b08c046..b7ac25c81e 100644 --- a/cmds/dumpstate/DumpstateUtil.h +++ b/cmds/dumpstate/DumpstateUtil.h @@ -205,12 +205,6 @@ int RunCommandToFd(int fd, const std::string& title, const std::vector<std::stri */ int DumpFileToFd(int fd, const std::string& title, const std::string& path); -/* - * Finds the process id by process name. - * |ps_name| the process name we want to search for - */ -int GetPidByName(const std::string& ps_name); - } // namespace dumpstate } // namespace os } // namespace android diff --git a/cmds/dumpstate/TEST_MAPPING b/cmds/dumpstate/TEST_MAPPING new file mode 100644 index 0000000000..083944f729 --- /dev/null +++ b/cmds/dumpstate/TEST_MAPPING @@ -0,0 +1,7 @@ +{ + "presubmit": [ + { + "name": "dumpstate_test" + } + ] +}
\ No newline at end of file diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp index cc745708c8..141662904e 100644 --- a/cmds/dumpstate/dumpstate.cpp +++ b/cmds/dumpstate/dumpstate.cpp @@ -22,6 +22,8 @@ #include <inttypes.h> #include <libgen.h> #include <limits.h> +#include <math.h> +#include <poll.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> @@ -32,6 +34,13 @@ #include <sys/stat.h> #include <sys/time.h> #include <sys/wait.h> +#include <signal.h> +#include <stdarg.h> +#include <string.h> +#include <sys/capability.h> +#include <sys/inotify.h> +#include <sys/klog.h> +#include <time.h> #include <unistd.h> #include <chrono> @@ -58,10 +67,13 @@ #include <binder/IServiceManager.h> #include <cutils/native_handle.h> #include <cutils/properties.h> +#include <cutils/sockets.h> #include <debuggerd/client.h> #include <dumpsys.h> #include <dumputils/dump_utils.h> +#include <hardware_legacy/power.h> #include <hidl/ServiceManagement.h> +#include <log/log.h> #include <openssl/sha.h> #include <private/android_filesystem_config.h> #include <private/android_logger.h> @@ -96,6 +108,26 @@ using android::os::dumpstate::DumpFileToFd; using android::os::dumpstate::DumpstateSectionReporter; using android::os::dumpstate::PropertiesHelper; +// Keep in sync with +// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java +static const int TRACE_DUMP_TIMEOUT_MS = 10000; // 10 seconds + +/* Most simple commands have 10 as timeout, so 5 is a good estimate */ +static const int32_t WEIGHT_FILE = 5; + +// TODO: temporary variables and functions used during C++ refactoring +static Dumpstate& ds = Dumpstate::GetInstance(); +static int RunCommand(const std::string& title, const std::vector<std::string>& full_command, + const CommandOptions& options = CommandOptions::DEFAULT) { + return ds.RunCommand(title, full_command, options); +} + +// Reasonable value for max stats. +static const int STATS_MAX_N_RUNS = 1000; +static const long STATS_MAX_AVERAGE = 100000; + +CommandOptions Dumpstate::DEFAULT_DUMPSYS = CommandOptions::WithTimeout(30).Build(); + typedef Dumpstate::ConsentCallback::ConsentResult UserConsentResult; /* read before root is shed */ @@ -132,7 +164,6 @@ static const std::string ANR_DIR = "/data/anr/"; static const std::string ANR_FILE_PREFIX = "anr_"; // TODO: temporary variables and functions used during C++ refactoring -static Dumpstate& ds = Dumpstate::GetInstance(); #define RETURN_IF_USER_DENIED_CONSENT() \ if (ds.IsUserConsentDenied()) { \ @@ -147,6 +178,8 @@ static Dumpstate& ds = Dumpstate::GetInstance(); func_ptr(__VA_ARGS__); \ RETURN_IF_USER_DENIED_CONSENT(); +static const char* WAKE_LOCK_NAME = "dumpstate_wakelock"; + namespace android { namespace os { namespace { @@ -234,10 +267,6 @@ int64_t GetModuleMetadataVersion() { } // namespace os } // namespace android -static int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand, - const CommandOptions& options = CommandOptions::DEFAULT) { - return ds.RunCommand(title, fullCommand, options); -} static void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs, const CommandOptions& options = Dumpstate::DEFAULT_DUMPSYS, long dumpsysTimeoutMs = 0) { @@ -2442,6 +2471,13 @@ Dumpstate::RunStatus Dumpstate::RunInternal(int32_t calling_uid, MYLOGI("begin\n"); + if (acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME) < 0) { + MYLOGE("Failed to acquire wake lock: %s\n", strerror(errno)); + } else { + // Wake lock will be released automatically on process death + MYLOGD("Wake lock acquired.\n"); + } + register_sig_handler(); // TODO(b/111441001): maybe skip if already started? @@ -2768,3 +2804,947 @@ int run_main(int argc, char* argv[]) { exit(2); } } + +// TODO(111441001): Default DumpOptions to sensible values. +Dumpstate::Dumpstate(const std::string& version) + : pid_(getpid()), + options_(new Dumpstate::DumpOptions()), + version_(version), + now_(time(nullptr)) { +} + +Dumpstate& Dumpstate::GetInstance() { + static Dumpstate singleton_(android::base::GetProperty("dumpstate.version", VERSION_CURRENT)); + return singleton_; +} + +DurationReporter::DurationReporter(const std::string& title, bool logcat_only) + : title_(title), logcat_only_(logcat_only) { + if (!title_.empty()) { + started_ = Nanotime(); + } +} + +DurationReporter::~DurationReporter() { + if (!title_.empty()) { + float elapsed = (float)(Nanotime() - started_) / NANOS_PER_SEC; + if (elapsed < .5f) { + return; + } + MYLOGD("Duration of '%s': %.2fs\n", title_.c_str(), elapsed); + if (logcat_only_) { + return; + } + // Use "Yoda grammar" to make it easier to grep|sort sections. + printf("------ %.3fs was the duration of '%s' ------\n", elapsed, title_.c_str()); + } +} + +const int32_t Progress::kDefaultMax = 5000; + +Progress::Progress(const std::string& path) : Progress(Progress::kDefaultMax, 1.1, path) { +} + +Progress::Progress(int32_t initial_max, int32_t progress, float growth_factor) + : Progress(initial_max, growth_factor, "") { + progress_ = progress; +} + +Progress::Progress(int32_t initial_max, float growth_factor, const std::string& path) + : initial_max_(initial_max), + progress_(0), + max_(initial_max), + growth_factor_(growth_factor), + n_runs_(0), + average_max_(0), + path_(path) { + if (!path_.empty()) { + Load(); + } +} + +void Progress::Load() { + MYLOGD("Loading stats from %s\n", path_.c_str()); + std::string content; + if (!android::base::ReadFileToString(path_, &content)) { + MYLOGI("Could not read stats from %s; using max of %d\n", path_.c_str(), max_); + return; + } + if (content.empty()) { + MYLOGE("No stats (empty file) on %s; using max of %d\n", path_.c_str(), max_); + return; + } + std::vector<std::string> lines = android::base::Split(content, "\n"); + + if (lines.size() < 1) { + MYLOGE("Invalid stats on file %s: not enough lines (%d). Using max of %d\n", path_.c_str(), + (int)lines.size(), max_); + return; + } + char* ptr; + n_runs_ = strtol(lines[0].c_str(), &ptr, 10); + average_max_ = strtol(ptr, nullptr, 10); + if (n_runs_ <= 0 || average_max_ <= 0 || n_runs_ > STATS_MAX_N_RUNS || + average_max_ > STATS_MAX_AVERAGE) { + MYLOGE("Invalid stats line on file %s: %s\n", path_.c_str(), lines[0].c_str()); + initial_max_ = Progress::kDefaultMax; + } else { + initial_max_ = average_max_; + } + max_ = initial_max_; + + MYLOGI("Average max progress: %d in %d runs; estimated max: %d\n", average_max_, n_runs_, max_); +} + +void Progress::Save() { + int32_t total = n_runs_ * average_max_ + progress_; + int32_t runs = n_runs_ + 1; + int32_t average = floor(((float)total) / runs); + MYLOGI("Saving stats (total=%d, runs=%d, average=%d) on %s\n", total, runs, average, + path_.c_str()); + if (path_.empty()) { + return; + } + + std::string content = android::base::StringPrintf("%d %d\n", runs, average); + if (!android::base::WriteStringToFile(content, path_)) { + MYLOGE("Could not save stats on %s\n", path_.c_str()); + } +} + +int32_t Progress::Get() const { + return progress_; +} + +bool Progress::Inc(int32_t delta_sec) { + bool changed = false; + if (delta_sec >= 0) { + progress_ += delta_sec; + if (progress_ > max_) { + int32_t old_max = max_; + max_ = floor((float)progress_ * growth_factor_); + MYLOGD("Adjusting max progress from %d to %d\n", old_max, max_); + changed = true; + } + } + return changed; +} + +int32_t Progress::GetMax() const { + return max_; +} + +int32_t Progress::GetInitialMax() const { + return initial_max_; +} + +void Progress::Dump(int fd, const std::string& prefix) const { + const char* pr = prefix.c_str(); + dprintf(fd, "%sprogress: %d\n", pr, progress_); + dprintf(fd, "%smax: %d\n", pr, max_); + dprintf(fd, "%sinitial_max: %d\n", pr, initial_max_); + dprintf(fd, "%sgrowth_factor: %0.2f\n", pr, growth_factor_); + dprintf(fd, "%spath: %s\n", pr, path_.c_str()); + dprintf(fd, "%sn_runs: %d\n", pr, n_runs_); + dprintf(fd, "%saverage_max: %d\n", pr, average_max_); +} + +bool Dumpstate::IsZipping() const { + return zip_writer_ != nullptr; +} + +std::string Dumpstate::GetPath(const std::string& suffix) const { + return GetPath(bugreport_internal_dir_, suffix); +} + +std::string Dumpstate::GetPath(const std::string& directory, const std::string& suffix) const { + return android::base::StringPrintf("%s/%s-%s%s", directory.c_str(), base_name_.c_str(), + name_.c_str(), suffix.c_str()); +} + +void Dumpstate::SetProgress(std::unique_ptr<Progress> progress) { + progress_ = std::move(progress); +} + +void for_each_userid(void (*func)(int), const char *header) { + std::string title = header == nullptr ? "for_each_userid" : android::base::StringPrintf( + "for_each_userid(%s)", header); + DurationReporter duration_reporter(title); + if (PropertiesHelper::IsDryRun()) return; + + DIR *d; + struct dirent *de; + + if (header) printf("\n------ %s ------\n", header); + func(0); + + if (!(d = opendir("/data/system/users"))) { + printf("Failed to open /data/system/users (%s)\n", strerror(errno)); + return; + } + + while ((de = readdir(d))) { + int userid; + if (de->d_type != DT_DIR || !(userid = atoi(de->d_name))) { + continue; + } + func(userid); + } + + closedir(d); +} + +static void __for_each_pid(void (*helper)(int, const char *, void *), const char *header, void *arg) { + DIR *d; + struct dirent *de; + + if (!(d = opendir("/proc"))) { + printf("Failed to open /proc (%s)\n", strerror(errno)); + return; + } + + if (header) printf("\n------ %s ------\n", header); + while ((de = readdir(d))) { + if (ds.IsUserConsentDenied()) { + MYLOGE( + "Returning early because user denied consent to share bugreport with calling app."); + closedir(d); + return; + } + int pid; + int fd; + char cmdpath[255]; + char cmdline[255]; + + if (!(pid = atoi(de->d_name))) { + continue; + } + + memset(cmdline, 0, sizeof(cmdline)); + + snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/cmdline", pid); + if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) { + TEMP_FAILURE_RETRY(read(fd, cmdline, sizeof(cmdline) - 2)); + close(fd); + if (cmdline[0]) { + helper(pid, cmdline, arg); + continue; + } + } + + // if no cmdline, a kernel thread has comm + snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/comm", pid); + if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) { + TEMP_FAILURE_RETRY(read(fd, cmdline + 1, sizeof(cmdline) - 4)); + close(fd); + if (cmdline[1]) { + cmdline[0] = '['; + size_t len = strcspn(cmdline, "\f\b\r\n"); + cmdline[len] = ']'; + cmdline[len+1] = '\0'; + } + } + if (!cmdline[0]) { + strcpy(cmdline, "N/A"); + } + helper(pid, cmdline, arg); + } + + closedir(d); +} + +static void for_each_pid_helper(int pid, const char *cmdline, void *arg) { + for_each_pid_func *func = (for_each_pid_func*) arg; + func(pid, cmdline); +} + +void for_each_pid(for_each_pid_func func, const char *header) { + std::string title = header == nullptr ? "for_each_pid" + : android::base::StringPrintf("for_each_pid(%s)", header); + DurationReporter duration_reporter(title); + if (PropertiesHelper::IsDryRun()) return; + + __for_each_pid(for_each_pid_helper, header, (void *) func); +} + +static void for_each_tid_helper(int pid, const char *cmdline, void *arg) { + DIR *d; + struct dirent *de; + char taskpath[255]; + for_each_tid_func *func = (for_each_tid_func *) arg; + + snprintf(taskpath, sizeof(taskpath), "/proc/%d/task", pid); + + if (!(d = opendir(taskpath))) { + printf("Failed to open %s (%s)\n", taskpath, strerror(errno)); + return; + } + + func(pid, pid, cmdline); + + while ((de = readdir(d))) { + if (ds.IsUserConsentDenied()) { + MYLOGE( + "Returning early because user denied consent to share bugreport with calling app."); + closedir(d); + return; + } + int tid; + int fd; + char commpath[255]; + char comm[255]; + + if (!(tid = atoi(de->d_name))) { + continue; + } + + if (tid == pid) + continue; + + snprintf(commpath, sizeof(commpath), "/proc/%d/comm", tid); + memset(comm, 0, sizeof(comm)); + if ((fd = TEMP_FAILURE_RETRY(open(commpath, O_RDONLY | O_CLOEXEC))) < 0) { + strcpy(comm, "N/A"); + } else { + char *c; + TEMP_FAILURE_RETRY(read(fd, comm, sizeof(comm) - 2)); + close(fd); + + c = strrchr(comm, '\n'); + if (c) { + *c = '\0'; + } + } + func(pid, tid, comm); + } + + closedir(d); +} + +void for_each_tid(for_each_tid_func func, const char *header) { + std::string title = header == nullptr ? "for_each_tid" + : android::base::StringPrintf("for_each_tid(%s)", header); + DurationReporter duration_reporter(title); + + if (PropertiesHelper::IsDryRun()) return; + + __for_each_pid(for_each_tid_helper, header, (void *) func); +} + +void show_wchan(int pid, int tid, const char *name) { + if (PropertiesHelper::IsDryRun()) return; + + char path[255]; + char buffer[255]; + int fd, ret, save_errno; + char name_buffer[255]; + + memset(buffer, 0, sizeof(buffer)); + + snprintf(path, sizeof(path), "/proc/%d/wchan", tid); + if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) { + printf("Failed to open '%s' (%s)\n", path, strerror(errno)); + return; + } + + ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer))); + save_errno = errno; + close(fd); + + if (ret < 0) { + printf("Failed to read '%s' (%s)\n", path, strerror(save_errno)); + return; + } + + snprintf(name_buffer, sizeof(name_buffer), "%*s%s", + pid == tid ? 0 : 3, "", name); + + printf("%-7d %-32s %s\n", tid, name_buffer, buffer); + + return; +} + +// print time in centiseconds +static void snprcent(char *buffer, size_t len, size_t spc, + unsigned long long time) { + static long hz; // cache discovered hz + + if (hz <= 0) { + hz = sysconf(_SC_CLK_TCK); + if (hz <= 0) { + hz = 1000; + } + } + + // convert to centiseconds + time = (time * 100 + (hz / 2)) / hz; + + char str[16]; + + snprintf(str, sizeof(str), " %llu.%02u", + time / 100, (unsigned)(time % 100)); + size_t offset = strlen(buffer); + snprintf(buffer + offset, (len > offset) ? len - offset : 0, + "%*s", (spc > offset) ? (int)(spc - offset) : 0, str); +} + +// print permille as a percent +static void snprdec(char *buffer, size_t len, size_t spc, unsigned permille) { + char str[16]; + + snprintf(str, sizeof(str), " %u.%u%%", permille / 10, permille % 10); + size_t offset = strlen(buffer); + snprintf(buffer + offset, (len > offset) ? len - offset : 0, + "%*s", (spc > offset) ? (int)(spc - offset) : 0, str); +} + +void show_showtime(int pid, const char *name) { + if (PropertiesHelper::IsDryRun()) return; + + char path[255]; + char buffer[1023]; + int fd, ret, save_errno; + + memset(buffer, 0, sizeof(buffer)); + + snprintf(path, sizeof(path), "/proc/%d/stat", pid); + if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) { + printf("Failed to open '%s' (%s)\n", path, strerror(errno)); + return; + } + + ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer))); + save_errno = errno; + close(fd); + + if (ret < 0) { + printf("Failed to read '%s' (%s)\n", path, strerror(save_errno)); + return; + } + + // field 14 is utime + // field 15 is stime + // field 42 is iotime + unsigned long long utime = 0, stime = 0, iotime = 0; + if (sscanf(buffer, + "%*u %*s %*s %*d %*d %*d %*d %*d %*d %*d %*d " + "%*d %*d %llu %llu %*d %*d %*d %*d %*d %*d " + "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d " + "%*d %*d %*d %*d %*d %*d %*d %*d %*d %llu ", + &utime, &stime, &iotime) != 3) { + return; + } + + unsigned long long total = utime + stime; + if (!total) { + return; + } + + unsigned permille = (iotime * 1000 + (total / 2)) / total; + if (permille > 1000) { + permille = 1000; + } + + // try to beautify and stabilize columns at <80 characters + snprintf(buffer, sizeof(buffer), "%-6d%s", pid, name); + if ((name[0] != '[') || utime) { + snprcent(buffer, sizeof(buffer), 57, utime); + } + snprcent(buffer, sizeof(buffer), 65, stime); + if ((name[0] != '[') || iotime) { + snprcent(buffer, sizeof(buffer), 73, iotime); + } + if (iotime) { + snprdec(buffer, sizeof(buffer), 79, permille); + } + puts(buffer); // adds a trailing newline + + return; +} + +void do_dmesg() { + const char *title = "KERNEL LOG (dmesg)"; + DurationReporter duration_reporter(title); + printf("------ %s ------\n", title); + + if (PropertiesHelper::IsDryRun()) return; + + /* Get size of kernel buffer */ + int size = klogctl(KLOG_SIZE_BUFFER, nullptr, 0); + if (size <= 0) { + printf("Unexpected klogctl return value: %d\n\n", size); + return; + } + char *buf = (char *) malloc(size + 1); + if (buf == nullptr) { + printf("memory allocation failed\n\n"); + return; + } + int retval = klogctl(KLOG_READ_ALL, buf, size); + if (retval < 0) { + printf("klogctl failure\n\n"); + free(buf); + return; + } + buf[retval] = '\0'; + printf("%s\n\n", buf); + free(buf); + return; +} + +void do_showmap(int pid, const char *name) { + char title[255]; + char arg[255]; + + snprintf(title, sizeof(title), "SHOW MAP %d (%s)", pid, name); + snprintf(arg, sizeof(arg), "%d", pid); + RunCommand(title, {"showmap", "-q", arg}, CommandOptions::AS_ROOT); +} + +int Dumpstate::DumpFile(const std::string& title, const std::string& path) { + DurationReporter duration_reporter(title); + + int status = DumpFileToFd(STDOUT_FILENO, title, path); + + UpdateProgress(WEIGHT_FILE); + + return status; +} + +int read_file_as_long(const char *path, long int *output) { + int fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC)); + if (fd < 0) { + int err = errno; + MYLOGE("Error opening file descriptor for %s: %s\n", path, strerror(err)); + return -1; + } + char buffer[50]; + ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer))); + if (bytes_read == -1) { + MYLOGE("Error reading file %s: %s\n", path, strerror(errno)); + return -2; + } + if (bytes_read == 0) { + MYLOGE("File %s is empty\n", path); + return -3; + } + *output = atoi(buffer); + return 0; +} + +/* calls skip to gate calling dump_from_fd recursively + * in the specified directory. dump_from_fd defaults to + * dump_file_from_fd above when set to NULL. skip defaults + * to false when set to NULL. dump_from_fd will always be + * called with title NULL. + */ +int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path), + int (*dump_from_fd)(const char* title, const char* path, int fd)) { + DurationReporter duration_reporter(title); + DIR *dirp; + struct dirent *d; + char *newpath = nullptr; + const char *slash = "/"; + int retval = 0; + + if (!title.empty()) { + printf("------ %s (%s) ------\n", title.c_str(), dir); + } + if (PropertiesHelper::IsDryRun()) return 0; + + if (dir[strlen(dir) - 1] == '/') { + ++slash; + } + dirp = opendir(dir); + if (dirp == nullptr) { + retval = -errno; + MYLOGE("%s: %s\n", dir, strerror(errno)); + return retval; + } + + if (!dump_from_fd) { + dump_from_fd = dump_file_from_fd; + } + for (; ((d = readdir(dirp))); free(newpath), newpath = nullptr) { + if ((d->d_name[0] == '.') + && (((d->d_name[1] == '.') && (d->d_name[2] == '\0')) + || (d->d_name[1] == '\0'))) { + continue; + } + asprintf(&newpath, "%s%s%s%s", dir, slash, d->d_name, + (d->d_type == DT_DIR) ? "/" : ""); + if (!newpath) { + retval = -errno; + continue; + } + if (skip && (*skip)(newpath)) { + continue; + } + if (d->d_type == DT_DIR) { + int ret = dump_files("", newpath, skip, dump_from_fd); + if (ret < 0) { + retval = ret; + } + continue; + } + android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(newpath, O_RDONLY | O_NONBLOCK | O_CLOEXEC))); + if (fd.get() < 0) { + retval = -1; + printf("*** %s: %s\n", newpath, strerror(errno)); + continue; + } + (*dump_from_fd)(nullptr, newpath, fd.get()); + } + closedir(dirp); + if (!title.empty()) { + printf("\n"); + } + return retval; +} + +/* fd must have been opened with the flag O_NONBLOCK. With this flag set, + * it's possible to avoid issues where opening the file itself can get + * stuck. + */ +int dump_file_from_fd(const char *title, const char *path, int fd) { + if (PropertiesHelper::IsDryRun()) return 0; + + int flags = fcntl(fd, F_GETFL); + if (flags == -1) { + printf("*** %s: failed to get flags on fd %d: %s\n", path, fd, strerror(errno)); + return -1; + } else if (!(flags & O_NONBLOCK)) { + printf("*** %s: fd must have O_NONBLOCK set.\n", path); + return -1; + } + return DumpFileFromFdToFd(title, path, fd, STDOUT_FILENO, PropertiesHelper::IsDryRun()); +} + +int Dumpstate::RunCommand(const std::string& title, const std::vector<std::string>& full_command, + const CommandOptions& options) { + DurationReporter duration_reporter(title); + + int status = RunCommandToFd(STDOUT_FILENO, title, full_command, options); + + /* TODO: for now we're simplifying the progress calculation by using the + * timeout as the weight. It's a good approximation for most cases, except when calling dumpsys, + * where its weight should be much higher proportionally to its timeout. + * Ideally, it should use a options.EstimatedDuration() instead...*/ + UpdateProgress(options.Timeout()); + + return status; +} + +void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args, + const CommandOptions& options, long dumpsysTimeoutMs) { + long timeout_ms = dumpsysTimeoutMs > 0 ? dumpsysTimeoutMs : options.TimeoutInMs(); + std::vector<std::string> dumpsys = {"/system/bin/dumpsys", "-T", std::to_string(timeout_ms)}; + dumpsys.insert(dumpsys.end(), dumpsys_args.begin(), dumpsys_args.end()); + RunCommand(title, dumpsys, options); +} + +int open_socket(const char *service) { + int s = android_get_control_socket(service); + if (s < 0) { + MYLOGE("android_get_control_socket(%s): %s\n", service, strerror(errno)); + return -1; + } + fcntl(s, F_SETFD, FD_CLOEXEC); + + // Set backlog to 0 to make sure that queue size will be minimum. + // In Linux, because the minimum queue will be 1, connect() will be blocked + // if the other clients already called connect() and the connection request was not accepted. + if (listen(s, 0) < 0) { + MYLOGE("listen(control socket): %s\n", strerror(errno)); + return -1; + } + + struct sockaddr addr; + socklen_t alen = sizeof(addr); + int fd = accept(s, &addr, &alen); + + // Close socket just after accept(), to make sure that connect() by client will get error + // when the socket is used by the other services. + // There is still a race condition possibility between accept and close, but there is no way + // to close-on-accept atomically. + // See detail; b/123306389#comment25 + close(s); + + if (fd < 0) { + MYLOGE("accept(control socket): %s\n", strerror(errno)); + return -1; + } + + return fd; +} + +/* redirect output to a service control socket */ +bool redirect_to_socket(FILE* redirect, const char* service) { + int fd = open_socket(service); + if (fd == -1) { + return false; + } + fflush(redirect); + // TODO: handle dup2 failure + TEMP_FAILURE_RETRY(dup2(fd, fileno(redirect))); + close(fd); + return true; +} + +// TODO: should call is_valid_output_file and/or be merged into it. +void create_parent_dirs(const char *path) { + char *chp = const_cast<char *> (path); + + /* skip initial slash */ + if (chp[0] == '/') + chp++; + + /* create leading directories, if necessary */ + struct stat dir_stat; + while (chp && chp[0]) { + chp = strchr(chp, '/'); + if (chp) { + *chp = 0; + if (stat(path, &dir_stat) == -1 || !S_ISDIR(dir_stat.st_mode)) { + MYLOGI("Creating directory %s\n", path); + if (mkdir(path, 0770)) { /* drwxrwx--- */ + MYLOGE("Unable to create directory %s: %s\n", path, strerror(errno)); + } else if (chown(path, AID_SHELL, AID_SHELL)) { + MYLOGE("Unable to change ownership of dir %s: %s\n", path, strerror(errno)); + } + } + *chp++ = '/'; + } + } +} + +bool _redirect_to_file(FILE* redirect, char* path, int truncate_flag) { + create_parent_dirs(path); + + int fd = TEMP_FAILURE_RETRY(open(path, + O_WRONLY | O_CREAT | truncate_flag | O_CLOEXEC | O_NOFOLLOW, + S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); + if (fd < 0) { + MYLOGE("%s: %s\n", path, strerror(errno)); + return false; + } + + TEMP_FAILURE_RETRY(dup2(fd, fileno(redirect))); + close(fd); + return true; +} + +bool redirect_to_file(FILE* redirect, char* path) { + return _redirect_to_file(redirect, path, O_TRUNC); +} + +bool redirect_to_existing_file(FILE* redirect, char* path) { + return _redirect_to_file(redirect, path, O_APPEND); +} + +void dump_route_tables() { + DurationReporter duration_reporter("DUMP ROUTE TABLES"); + if (PropertiesHelper::IsDryRun()) return; + const char* const RT_TABLES_PATH = "/data/misc/net/rt_tables"; + ds.DumpFile("RT_TABLES", RT_TABLES_PATH); + FILE* fp = fopen(RT_TABLES_PATH, "re"); + if (!fp) { + printf("*** %s: %s\n", RT_TABLES_PATH, strerror(errno)); + return; + } + char table[16]; + // Each line has an integer (the table number), a space, and a string (the table name). We only + // need the table number. It's a 32-bit unsigned number, so max 10 chars. Skip the table name. + // Add a fixed max limit so this doesn't go awry. + for (int i = 0; i < 64 && fscanf(fp, " %10s %*s", table) == 1; ++i) { + RunCommand("ROUTE TABLE IPv4", {"ip", "-4", "route", "show", "table", table}); + RunCommand("ROUTE TABLE IPv6", {"ip", "-6", "route", "show", "table", table}); + } + fclose(fp); +} + +// TODO: make this function thread safe if sections are generated in parallel. +void Dumpstate::UpdateProgress(int32_t delta_sec) { + if (progress_ == nullptr) { + MYLOGE("UpdateProgress: progress_ not set\n"); + return; + } + + // Always update progess so stats can be tuned... + bool max_changed = progress_->Inc(delta_sec); + + // ...but only notifiy listeners when necessary. + if (!options_->do_progress_updates) return; + + int progress = progress_->Get(); + int max = progress_->GetMax(); + + // adjusts max on the fly + if (max_changed && listener_ != nullptr) { + listener_->onMaxProgressUpdated(max); + } + + int32_t last_update_delta = progress - last_updated_progress_; + if (last_updated_progress_ > 0 && last_update_delta < update_progress_threshold_) { + return; + } + last_updated_progress_ = progress; + + if (control_socket_fd_ >= 0) { + dprintf(control_socket_fd_, "PROGRESS:%d/%d\n", progress, max); + fsync(control_socket_fd_); + } + + int percent = 100 * progress / max; + if (listener_ != nullptr) { + if (percent % 5 == 0) { + // We don't want to spam logcat, so only log multiples of 5. + MYLOGD("Setting progress (%s): %d/%d (%d%%)\n", listener_name_.c_str(), progress, max, + percent); + } else { + // stderr is ignored on normal invocations, but useful when calling + // /system/bin/dumpstate directly for debuggging. + fprintf(stderr, "Setting progress (%s): %d/%d (%d%%)\n", listener_name_.c_str(), + progress, max, percent); + } + // TODO(b/111441001): Remove in favor of onProgress + listener_->onProgressUpdated(progress); + + listener_->onProgress(percent); + } +} + +void Dumpstate::TakeScreenshot(const std::string& path) { + const std::string& real_path = path.empty() ? screenshot_path_ : path; + int status = + RunCommand("", {"/system/bin/screencap", "-p", real_path}, + CommandOptions::WithTimeout(10).Always().DropRoot().RedirectStderr().Build()); + if (status == 0) { + MYLOGD("Screenshot saved on %s\n", real_path.c_str()); + } else { + MYLOGE("Failed to take screenshot on %s\n", real_path.c_str()); + } +} + +bool is_dir(const char* pathname) { + struct stat info; + if (stat(pathname, &info) == -1) { + return false; + } + return S_ISDIR(info.st_mode); +} + +time_t get_mtime(int fd, time_t default_mtime) { + struct stat info; + if (fstat(fd, &info) == -1) { + return default_mtime; + } + return info.st_mtime; +} + +void dump_emmc_ecsd(const char *ext_csd_path) { + // List of interesting offsets + struct hex { + char str[2]; + }; + static const size_t EXT_CSD_REV = 192 * sizeof(hex); + static const size_t EXT_PRE_EOL_INFO = 267 * sizeof(hex); + static const size_t EXT_DEVICE_LIFE_TIME_EST_TYP_A = 268 * sizeof(hex); + static const size_t EXT_DEVICE_LIFE_TIME_EST_TYP_B = 269 * sizeof(hex); + + std::string buffer; + if (!android::base::ReadFileToString(ext_csd_path, &buffer)) { + return; + } + + printf("------ %s Extended CSD ------\n", ext_csd_path); + + if (buffer.length() < (EXT_CSD_REV + sizeof(hex))) { + printf("*** %s: truncated content %zu\n\n", ext_csd_path, buffer.length()); + return; + } + + int ext_csd_rev = 0; + std::string sub = buffer.substr(EXT_CSD_REV, sizeof(hex)); + if (sscanf(sub.c_str(), "%2x", &ext_csd_rev) != 1) { + printf("*** %s: EXT_CSD_REV parse error \"%s\"\n\n", ext_csd_path, sub.c_str()); + return; + } + + static const char *ver_str[] = { + "4.0", "4.1", "4.2", "4.3", "Obsolete", "4.41", "4.5", "5.0" + }; + printf("rev 1.%d (MMC %s)\n", ext_csd_rev, + (ext_csd_rev < (int)(sizeof(ver_str) / sizeof(ver_str[0]))) ? ver_str[ext_csd_rev] + : "Unknown"); + if (ext_csd_rev < 7) { + printf("\n"); + return; + } + + if (buffer.length() < (EXT_PRE_EOL_INFO + sizeof(hex))) { + printf("*** %s: truncated content %zu\n\n", ext_csd_path, buffer.length()); + return; + } + + int ext_pre_eol_info = 0; + sub = buffer.substr(EXT_PRE_EOL_INFO, sizeof(hex)); + if (sscanf(sub.c_str(), "%2x", &ext_pre_eol_info) != 1) { + printf("*** %s: PRE_EOL_INFO parse error \"%s\"\n\n", ext_csd_path, sub.c_str()); + return; + } + + static const char *eol_str[] = { + "Undefined", + "Normal", + "Warning (consumed 80% of reserve)", + "Urgent (consumed 90% of reserve)" + }; + printf( + "PRE_EOL_INFO %d (MMC %s)\n", ext_pre_eol_info, + eol_str[(ext_pre_eol_info < (int)(sizeof(eol_str) / sizeof(eol_str[0]))) ? ext_pre_eol_info + : 0]); + + for (size_t lifetime = EXT_DEVICE_LIFE_TIME_EST_TYP_A; + lifetime <= EXT_DEVICE_LIFE_TIME_EST_TYP_B; + lifetime += sizeof(hex)) { + int ext_device_life_time_est; + static const char *est_str[] = { + "Undefined", + "0-10% of device lifetime used", + "10-20% of device lifetime used", + "20-30% of device lifetime used", + "30-40% of device lifetime used", + "40-50% of device lifetime used", + "50-60% of device lifetime used", + "60-70% of device lifetime used", + "70-80% of device lifetime used", + "80-90% of device lifetime used", + "90-100% of device lifetime used", + "Exceeded the maximum estimated device lifetime", + }; + + if (buffer.length() < (lifetime + sizeof(hex))) { + printf("*** %s: truncated content %zu\n", ext_csd_path, buffer.length()); + break; + } + + ext_device_life_time_est = 0; + sub = buffer.substr(lifetime, sizeof(hex)); + if (sscanf(sub.c_str(), "%2x", &ext_device_life_time_est) != 1) { + printf("*** %s: DEVICE_LIFE_TIME_EST_TYP_%c parse error \"%s\"\n", ext_csd_path, + (unsigned)((lifetime - EXT_DEVICE_LIFE_TIME_EST_TYP_A) / sizeof(hex)) + 'A', + sub.c_str()); + continue; + } + printf("DEVICE_LIFE_TIME_EST_TYP_%c %d (MMC %s)\n", + (unsigned)((lifetime - EXT_DEVICE_LIFE_TIME_EST_TYP_A) / sizeof(hex)) + 'A', + ext_device_life_time_est, + est_str[(ext_device_life_time_est < (int)(sizeof(est_str) / sizeof(est_str[0]))) + ? ext_device_life_time_est + : 0]); + } + + printf("\n"); +} + diff --git a/cmds/dumpstate/tests/dumpstate_test.cpp b/cmds/dumpstate/tests/dumpstate_test.cpp index 0e88e43258..4e6b084ff6 100644 --- a/cmds/dumpstate/tests/dumpstate_test.cpp +++ b/cmds/dumpstate/tests/dumpstate_test.cpp @@ -1406,14 +1406,6 @@ class DumpstateUtilTest : public DumpstateBaseTest { return status; } - // Find out the pid of the process_name - int FindPidOfProcess(const std::string& process_name) { - CaptureStderr(); - int status = GetPidByName(process_name); - err = GetCapturedStderr(); - return status; - } - int fd; // 'fd` output and `stderr` from the last command ran. @@ -1763,18 +1755,6 @@ TEST_F(DumpstateUtilTest, DumpFileOnDryRun) { EXPECT_THAT(out, EndsWith("skipped on dry run\n")); } -TEST_F(DumpstateUtilTest, FindingPidWithExistingProcess) { - // init process always has pid 1. - EXPECT_EQ(1, FindPidOfProcess("init")); - EXPECT_THAT(err, IsEmpty()); -} - -TEST_F(DumpstateUtilTest, FindingPidWithNotExistingProcess) { - // find the process with abnormal name. - EXPECT_EQ(-1, FindPidOfProcess("abcdef12345-543")); - EXPECT_THAT(err, StrEq("can't find the pid\n")); -} - } // namespace dumpstate } // namespace os } // namespace android diff --git a/cmds/dumpstate/utils.cpp b/cmds/dumpstate/utils.cpp deleted file mode 100644 index 4cbf5776d3..0000000000 --- a/cmds/dumpstate/utils.cpp +++ /dev/null @@ -1,1017 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * 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. - */ - -#define LOG_TAG "dumpstate" - -#include "dumpstate.h" - -#include <dirent.h> -#include <fcntl.h> -#include <libgen.h> -#include <math.h> -#include <poll.h> -#include <signal.h> -#include <stdarg.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <sys/capability.h> -#include <sys/inotify.h> -#include <sys/klog.h> -#include <sys/prctl.h> -#include <sys/stat.h> -#include <sys/time.h> -#include <sys/wait.h> -#include <time.h> -#include <unistd.h> - -#include <memory> -#include <set> -#include <string> -#include <vector> - -#include <android-base/file.h> -#include <android-base/properties.h> -#include <android-base/stringprintf.h> -#include <android-base/strings.h> -#include <android-base/unique_fd.h> -#include <cutils/properties.h> -#include <cutils/sockets.h> -#include <log/log.h> -#include <private/android_filesystem_config.h> - -#include "DumpstateInternal.h" - -// TODO: remove once moved to namespace -using android::os::dumpstate::CommandOptions; -using android::os::dumpstate::DumpFileToFd; -using android::os::dumpstate::PropertiesHelper; - -// Keep in sync with -// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java -static const int TRACE_DUMP_TIMEOUT_MS = 10000; // 10 seconds - -/* Most simple commands have 10 as timeout, so 5 is a good estimate */ -static const int32_t WEIGHT_FILE = 5; - -// TODO: temporary variables and functions used during C++ refactoring -static Dumpstate& ds = Dumpstate::GetInstance(); -static int RunCommand(const std::string& title, const std::vector<std::string>& full_command, - const CommandOptions& options = CommandOptions::DEFAULT) { - return ds.RunCommand(title, full_command, options); -} - -// Reasonable value for max stats. -static const int STATS_MAX_N_RUNS = 1000; -static const long STATS_MAX_AVERAGE = 100000; - -CommandOptions Dumpstate::DEFAULT_DUMPSYS = CommandOptions::WithTimeout(30).Build(); - -// TODO(111441001): Default DumpOptions to sensible values. -Dumpstate::Dumpstate(const std::string& version) - : pid_(getpid()), - options_(new Dumpstate::DumpOptions()), - version_(version), - now_(time(nullptr)) { -} - -Dumpstate& Dumpstate::GetInstance() { - static Dumpstate singleton_(android::base::GetProperty("dumpstate.version", VERSION_CURRENT)); - return singleton_; -} - -DurationReporter::DurationReporter(const std::string& title, bool logcat_only) - : title_(title), logcat_only_(logcat_only) { - if (!title_.empty()) { - started_ = Nanotime(); - } -} - -DurationReporter::~DurationReporter() { - if (!title_.empty()) { - float elapsed = (float)(Nanotime() - started_) / NANOS_PER_SEC; - if (elapsed < .5f) { - return; - } - MYLOGD("Duration of '%s': %.2fs\n", title_.c_str(), elapsed); - if (logcat_only_) { - return; - } - // Use "Yoda grammar" to make it easier to grep|sort sections. - printf("------ %.3fs was the duration of '%s' ------\n", elapsed, title_.c_str()); - } -} - -const int32_t Progress::kDefaultMax = 5000; - -Progress::Progress(const std::string& path) : Progress(Progress::kDefaultMax, 1.1, path) { -} - -Progress::Progress(int32_t initial_max, int32_t progress, float growth_factor) - : Progress(initial_max, growth_factor, "") { - progress_ = progress; -} - -Progress::Progress(int32_t initial_max, float growth_factor, const std::string& path) - : initial_max_(initial_max), - progress_(0), - max_(initial_max), - growth_factor_(growth_factor), - n_runs_(0), - average_max_(0), - path_(path) { - if (!path_.empty()) { - Load(); - } -} - -void Progress::Load() { - MYLOGD("Loading stats from %s\n", path_.c_str()); - std::string content; - if (!android::base::ReadFileToString(path_, &content)) { - MYLOGI("Could not read stats from %s; using max of %d\n", path_.c_str(), max_); - return; - } - if (content.empty()) { - MYLOGE("No stats (empty file) on %s; using max of %d\n", path_.c_str(), max_); - return; - } - std::vector<std::string> lines = android::base::Split(content, "\n"); - - if (lines.size() < 1) { - MYLOGE("Invalid stats on file %s: not enough lines (%d). Using max of %d\n", path_.c_str(), - (int)lines.size(), max_); - return; - } - char* ptr; - n_runs_ = strtol(lines[0].c_str(), &ptr, 10); - average_max_ = strtol(ptr, nullptr, 10); - if (n_runs_ <= 0 || average_max_ <= 0 || n_runs_ > STATS_MAX_N_RUNS || - average_max_ > STATS_MAX_AVERAGE) { - MYLOGE("Invalid stats line on file %s: %s\n", path_.c_str(), lines[0].c_str()); - initial_max_ = Progress::kDefaultMax; - } else { - initial_max_ = average_max_; - } - max_ = initial_max_; - - MYLOGI("Average max progress: %d in %d runs; estimated max: %d\n", average_max_, n_runs_, max_); -} - -void Progress::Save() { - int32_t total = n_runs_ * average_max_ + progress_; - int32_t runs = n_runs_ + 1; - int32_t average = floor(((float)total) / runs); - MYLOGI("Saving stats (total=%d, runs=%d, average=%d) on %s\n", total, runs, average, - path_.c_str()); - if (path_.empty()) { - return; - } - - std::string content = android::base::StringPrintf("%d %d\n", runs, average); - if (!android::base::WriteStringToFile(content, path_)) { - MYLOGE("Could not save stats on %s\n", path_.c_str()); - } -} - -int32_t Progress::Get() const { - return progress_; -} - -bool Progress::Inc(int32_t delta_sec) { - bool changed = false; - if (delta_sec >= 0) { - progress_ += delta_sec; - if (progress_ > max_) { - int32_t old_max = max_; - max_ = floor((float)progress_ * growth_factor_); - MYLOGD("Adjusting max progress from %d to %d\n", old_max, max_); - changed = true; - } - } - return changed; -} - -int32_t Progress::GetMax() const { - return max_; -} - -int32_t Progress::GetInitialMax() const { - return initial_max_; -} - -void Progress::Dump(int fd, const std::string& prefix) const { - const char* pr = prefix.c_str(); - dprintf(fd, "%sprogress: %d\n", pr, progress_); - dprintf(fd, "%smax: %d\n", pr, max_); - dprintf(fd, "%sinitial_max: %d\n", pr, initial_max_); - dprintf(fd, "%sgrowth_factor: %0.2f\n", pr, growth_factor_); - dprintf(fd, "%spath: %s\n", pr, path_.c_str()); - dprintf(fd, "%sn_runs: %d\n", pr, n_runs_); - dprintf(fd, "%saverage_max: %d\n", pr, average_max_); -} - -bool Dumpstate::IsZipping() const { - return zip_writer_ != nullptr; -} - -std::string Dumpstate::GetPath(const std::string& suffix) const { - return GetPath(bugreport_internal_dir_, suffix); -} - -std::string Dumpstate::GetPath(const std::string& directory, const std::string& suffix) const { - return android::base::StringPrintf("%s/%s-%s%s", directory.c_str(), base_name_.c_str(), - name_.c_str(), suffix.c_str()); -} - -void Dumpstate::SetProgress(std::unique_ptr<Progress> progress) { - progress_ = std::move(progress); -} - -void for_each_userid(void (*func)(int), const char *header) { - std::string title = header == nullptr ? "for_each_userid" : android::base::StringPrintf( - "for_each_userid(%s)", header); - DurationReporter duration_reporter(title); - if (PropertiesHelper::IsDryRun()) return; - - DIR *d; - struct dirent *de; - - if (header) printf("\n------ %s ------\n", header); - func(0); - - if (!(d = opendir("/data/system/users"))) { - printf("Failed to open /data/system/users (%s)\n", strerror(errno)); - return; - } - - while ((de = readdir(d))) { - int userid; - if (de->d_type != DT_DIR || !(userid = atoi(de->d_name))) { - continue; - } - func(userid); - } - - closedir(d); -} - -static void __for_each_pid(void (*helper)(int, const char *, void *), const char *header, void *arg) { - DIR *d; - struct dirent *de; - - if (!(d = opendir("/proc"))) { - printf("Failed to open /proc (%s)\n", strerror(errno)); - return; - } - - if (header) printf("\n------ %s ------\n", header); - while ((de = readdir(d))) { - if (ds.IsUserConsentDenied()) { - MYLOGE( - "Returning early because user denied consent to share bugreport with calling app."); - closedir(d); - return; - } - int pid; - int fd; - char cmdpath[255]; - char cmdline[255]; - - if (!(pid = atoi(de->d_name))) { - continue; - } - - memset(cmdline, 0, sizeof(cmdline)); - - snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/cmdline", pid); - if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) { - TEMP_FAILURE_RETRY(read(fd, cmdline, sizeof(cmdline) - 2)); - close(fd); - if (cmdline[0]) { - helper(pid, cmdline, arg); - continue; - } - } - - // if no cmdline, a kernel thread has comm - snprintf(cmdpath, sizeof(cmdpath), "/proc/%d/comm", pid); - if ((fd = TEMP_FAILURE_RETRY(open(cmdpath, O_RDONLY | O_CLOEXEC))) >= 0) { - TEMP_FAILURE_RETRY(read(fd, cmdline + 1, sizeof(cmdline) - 4)); - close(fd); - if (cmdline[1]) { - cmdline[0] = '['; - size_t len = strcspn(cmdline, "\f\b\r\n"); - cmdline[len] = ']'; - cmdline[len+1] = '\0'; - } - } - if (!cmdline[0]) { - strcpy(cmdline, "N/A"); - } - helper(pid, cmdline, arg); - } - - closedir(d); -} - -static void for_each_pid_helper(int pid, const char *cmdline, void *arg) { - for_each_pid_func *func = (for_each_pid_func*) arg; - func(pid, cmdline); -} - -void for_each_pid(for_each_pid_func func, const char *header) { - std::string title = header == nullptr ? "for_each_pid" - : android::base::StringPrintf("for_each_pid(%s)", header); - DurationReporter duration_reporter(title); - if (PropertiesHelper::IsDryRun()) return; - - __for_each_pid(for_each_pid_helper, header, (void *) func); -} - -static void for_each_tid_helper(int pid, const char *cmdline, void *arg) { - DIR *d; - struct dirent *de; - char taskpath[255]; - for_each_tid_func *func = (for_each_tid_func *) arg; - - snprintf(taskpath, sizeof(taskpath), "/proc/%d/task", pid); - - if (!(d = opendir(taskpath))) { - printf("Failed to open %s (%s)\n", taskpath, strerror(errno)); - return; - } - - func(pid, pid, cmdline); - - while ((de = readdir(d))) { - if (ds.IsUserConsentDenied()) { - MYLOGE( - "Returning early because user denied consent to share bugreport with calling app."); - closedir(d); - return; - } - int tid; - int fd; - char commpath[255]; - char comm[255]; - - if (!(tid = atoi(de->d_name))) { - continue; - } - - if (tid == pid) - continue; - - snprintf(commpath, sizeof(commpath), "/proc/%d/comm", tid); - memset(comm, 0, sizeof(comm)); - if ((fd = TEMP_FAILURE_RETRY(open(commpath, O_RDONLY | O_CLOEXEC))) < 0) { - strcpy(comm, "N/A"); - } else { - char *c; - TEMP_FAILURE_RETRY(read(fd, comm, sizeof(comm) - 2)); - close(fd); - - c = strrchr(comm, '\n'); - if (c) { - *c = '\0'; - } - } - func(pid, tid, comm); - } - - closedir(d); -} - -void for_each_tid(for_each_tid_func func, const char *header) { - std::string title = header == nullptr ? "for_each_tid" - : android::base::StringPrintf("for_each_tid(%s)", header); - DurationReporter duration_reporter(title); - - if (PropertiesHelper::IsDryRun()) return; - - __for_each_pid(for_each_tid_helper, header, (void *) func); -} - -void show_wchan(int pid, int tid, const char *name) { - if (PropertiesHelper::IsDryRun()) return; - - char path[255]; - char buffer[255]; - int fd, ret, save_errno; - char name_buffer[255]; - - memset(buffer, 0, sizeof(buffer)); - - snprintf(path, sizeof(path), "/proc/%d/wchan", tid); - if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) { - printf("Failed to open '%s' (%s)\n", path, strerror(errno)); - return; - } - - ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer))); - save_errno = errno; - close(fd); - - if (ret < 0) { - printf("Failed to read '%s' (%s)\n", path, strerror(save_errno)); - return; - } - - snprintf(name_buffer, sizeof(name_buffer), "%*s%s", - pid == tid ? 0 : 3, "", name); - - printf("%-7d %-32s %s\n", tid, name_buffer, buffer); - - return; -} - -// print time in centiseconds -static void snprcent(char *buffer, size_t len, size_t spc, - unsigned long long time) { - static long hz; // cache discovered hz - - if (hz <= 0) { - hz = sysconf(_SC_CLK_TCK); - if (hz <= 0) { - hz = 1000; - } - } - - // convert to centiseconds - time = (time * 100 + (hz / 2)) / hz; - - char str[16]; - - snprintf(str, sizeof(str), " %llu.%02u", - time / 100, (unsigned)(time % 100)); - size_t offset = strlen(buffer); - snprintf(buffer + offset, (len > offset) ? len - offset : 0, - "%*s", (spc > offset) ? (int)(spc - offset) : 0, str); -} - -// print permille as a percent -static void snprdec(char *buffer, size_t len, size_t spc, unsigned permille) { - char str[16]; - - snprintf(str, sizeof(str), " %u.%u%%", permille / 10, permille % 10); - size_t offset = strlen(buffer); - snprintf(buffer + offset, (len > offset) ? len - offset : 0, - "%*s", (spc > offset) ? (int)(spc - offset) : 0, str); -} - -void show_showtime(int pid, const char *name) { - if (PropertiesHelper::IsDryRun()) return; - - char path[255]; - char buffer[1023]; - int fd, ret, save_errno; - - memset(buffer, 0, sizeof(buffer)); - - snprintf(path, sizeof(path), "/proc/%d/stat", pid); - if ((fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC))) < 0) { - printf("Failed to open '%s' (%s)\n", path, strerror(errno)); - return; - } - - ret = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer))); - save_errno = errno; - close(fd); - - if (ret < 0) { - printf("Failed to read '%s' (%s)\n", path, strerror(save_errno)); - return; - } - - // field 14 is utime - // field 15 is stime - // field 42 is iotime - unsigned long long utime = 0, stime = 0, iotime = 0; - if (sscanf(buffer, - "%*u %*s %*s %*d %*d %*d %*d %*d %*d %*d %*d " - "%*d %*d %llu %llu %*d %*d %*d %*d %*d %*d " - "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d " - "%*d %*d %*d %*d %*d %*d %*d %*d %*d %llu ", - &utime, &stime, &iotime) != 3) { - return; - } - - unsigned long long total = utime + stime; - if (!total) { - return; - } - - unsigned permille = (iotime * 1000 + (total / 2)) / total; - if (permille > 1000) { - permille = 1000; - } - - // try to beautify and stabilize columns at <80 characters - snprintf(buffer, sizeof(buffer), "%-6d%s", pid, name); - if ((name[0] != '[') || utime) { - snprcent(buffer, sizeof(buffer), 57, utime); - } - snprcent(buffer, sizeof(buffer), 65, stime); - if ((name[0] != '[') || iotime) { - snprcent(buffer, sizeof(buffer), 73, iotime); - } - if (iotime) { - snprdec(buffer, sizeof(buffer), 79, permille); - } - puts(buffer); // adds a trailing newline - - return; -} - -void do_dmesg() { - const char *title = "KERNEL LOG (dmesg)"; - DurationReporter duration_reporter(title); - printf("------ %s ------\n", title); - - if (PropertiesHelper::IsDryRun()) return; - - /* Get size of kernel buffer */ - int size = klogctl(KLOG_SIZE_BUFFER, nullptr, 0); - if (size <= 0) { - printf("Unexpected klogctl return value: %d\n\n", size); - return; - } - char *buf = (char *) malloc(size + 1); - if (buf == nullptr) { - printf("memory allocation failed\n\n"); - return; - } - int retval = klogctl(KLOG_READ_ALL, buf, size); - if (retval < 0) { - printf("klogctl failure\n\n"); - free(buf); - return; - } - buf[retval] = '\0'; - printf("%s\n\n", buf); - free(buf); - return; -} - -void do_showmap(int pid, const char *name) { - char title[255]; - char arg[255]; - - snprintf(title, sizeof(title), "SHOW MAP %d (%s)", pid, name); - snprintf(arg, sizeof(arg), "%d", pid); - RunCommand(title, {"showmap", "-q", arg}, CommandOptions::AS_ROOT); -} - -int Dumpstate::DumpFile(const std::string& title, const std::string& path) { - DurationReporter duration_reporter(title); - - int status = DumpFileToFd(STDOUT_FILENO, title, path); - - UpdateProgress(WEIGHT_FILE); - - return status; -} - -int read_file_as_long(const char *path, long int *output) { - int fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC)); - if (fd < 0) { - int err = errno; - MYLOGE("Error opening file descriptor for %s: %s\n", path, strerror(err)); - return -1; - } - char buffer[50]; - ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer))); - if (bytes_read == -1) { - MYLOGE("Error reading file %s: %s\n", path, strerror(errno)); - return -2; - } - if (bytes_read == 0) { - MYLOGE("File %s is empty\n", path); - return -3; - } - *output = atoi(buffer); - return 0; -} - -/* calls skip to gate calling dump_from_fd recursively - * in the specified directory. dump_from_fd defaults to - * dump_file_from_fd above when set to NULL. skip defaults - * to false when set to NULL. dump_from_fd will always be - * called with title NULL. - */ -int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path), - int (*dump_from_fd)(const char* title, const char* path, int fd)) { - DurationReporter duration_reporter(title); - DIR *dirp; - struct dirent *d; - char *newpath = nullptr; - const char *slash = "/"; - int retval = 0; - - if (!title.empty()) { - printf("------ %s (%s) ------\n", title.c_str(), dir); - } - if (PropertiesHelper::IsDryRun()) return 0; - - if (dir[strlen(dir) - 1] == '/') { - ++slash; - } - dirp = opendir(dir); - if (dirp == nullptr) { - retval = -errno; - MYLOGE("%s: %s\n", dir, strerror(errno)); - return retval; - } - - if (!dump_from_fd) { - dump_from_fd = dump_file_from_fd; - } - for (; ((d = readdir(dirp))); free(newpath), newpath = nullptr) { - if ((d->d_name[0] == '.') - && (((d->d_name[1] == '.') && (d->d_name[2] == '\0')) - || (d->d_name[1] == '\0'))) { - continue; - } - asprintf(&newpath, "%s%s%s%s", dir, slash, d->d_name, - (d->d_type == DT_DIR) ? "/" : ""); - if (!newpath) { - retval = -errno; - continue; - } - if (skip && (*skip)(newpath)) { - continue; - } - if (d->d_type == DT_DIR) { - int ret = dump_files("", newpath, skip, dump_from_fd); - if (ret < 0) { - retval = ret; - } - continue; - } - android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(newpath, O_RDONLY | O_NONBLOCK | O_CLOEXEC))); - if (fd.get() < 0) { - retval = -1; - printf("*** %s: %s\n", newpath, strerror(errno)); - continue; - } - (*dump_from_fd)(nullptr, newpath, fd.get()); - } - closedir(dirp); - if (!title.empty()) { - printf("\n"); - } - return retval; -} - -/* fd must have been opened with the flag O_NONBLOCK. With this flag set, - * it's possible to avoid issues where opening the file itself can get - * stuck. - */ -int dump_file_from_fd(const char *title, const char *path, int fd) { - if (PropertiesHelper::IsDryRun()) return 0; - - int flags = fcntl(fd, F_GETFL); - if (flags == -1) { - printf("*** %s: failed to get flags on fd %d: %s\n", path, fd, strerror(errno)); - return -1; - } else if (!(flags & O_NONBLOCK)) { - printf("*** %s: fd must have O_NONBLOCK set.\n", path); - return -1; - } - return DumpFileFromFdToFd(title, path, fd, STDOUT_FILENO, PropertiesHelper::IsDryRun()); -} - -int Dumpstate::RunCommand(const std::string& title, const std::vector<std::string>& full_command, - const CommandOptions& options) { - DurationReporter duration_reporter(title); - - int status = RunCommandToFd(STDOUT_FILENO, title, full_command, options); - - /* TODO: for now we're simplifying the progress calculation by using the - * timeout as the weight. It's a good approximation for most cases, except when calling dumpsys, - * where its weight should be much higher proportionally to its timeout. - * Ideally, it should use a options.EstimatedDuration() instead...*/ - UpdateProgress(options.Timeout()); - - return status; -} - -void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args, - const CommandOptions& options, long dumpsysTimeoutMs) { - long timeout_ms = dumpsysTimeoutMs > 0 ? dumpsysTimeoutMs : options.TimeoutInMs(); - std::vector<std::string> dumpsys = {"/system/bin/dumpsys", "-T", std::to_string(timeout_ms)}; - dumpsys.insert(dumpsys.end(), dumpsys_args.begin(), dumpsys_args.end()); - RunCommand(title, dumpsys, options); -} - -int open_socket(const char *service) { - int s = android_get_control_socket(service); - if (s < 0) { - MYLOGE("android_get_control_socket(%s): %s\n", service, strerror(errno)); - return -1; - } - fcntl(s, F_SETFD, FD_CLOEXEC); - if (listen(s, 4) < 0) { - MYLOGE("listen(control socket): %s\n", strerror(errno)); - return -1; - } - - struct sockaddr addr; - socklen_t alen = sizeof(addr); - int fd = accept(s, &addr, &alen); - - // Close socket just after accept(), to make sure that connect() by client will get error - // when the socket is used by the other services. - close(s); - - if (fd < 0) { - MYLOGE("accept(control socket): %s\n", strerror(errno)); - return -1; - } - - return fd; -} - -/* redirect output to a service control socket */ -bool redirect_to_socket(FILE* redirect, const char* service) { - int fd = open_socket(service); - if (fd == -1) { - return false; - } - fflush(redirect); - // TODO: handle dup2 failure - TEMP_FAILURE_RETRY(dup2(fd, fileno(redirect))); - close(fd); - return true; -} - -// TODO: should call is_valid_output_file and/or be merged into it. -void create_parent_dirs(const char *path) { - char *chp = const_cast<char *> (path); - - /* skip initial slash */ - if (chp[0] == '/') - chp++; - - /* create leading directories, if necessary */ - struct stat dir_stat; - while (chp && chp[0]) { - chp = strchr(chp, '/'); - if (chp) { - *chp = 0; - if (stat(path, &dir_stat) == -1 || !S_ISDIR(dir_stat.st_mode)) { - MYLOGI("Creating directory %s\n", path); - if (mkdir(path, 0770)) { /* drwxrwx--- */ - MYLOGE("Unable to create directory %s: %s\n", path, strerror(errno)); - } else if (chown(path, AID_SHELL, AID_SHELL)) { - MYLOGE("Unable to change ownership of dir %s: %s\n", path, strerror(errno)); - } - } - *chp++ = '/'; - } - } -} - -bool _redirect_to_file(FILE* redirect, char* path, int truncate_flag) { - create_parent_dirs(path); - - int fd = TEMP_FAILURE_RETRY(open(path, - O_WRONLY | O_CREAT | truncate_flag | O_CLOEXEC | O_NOFOLLOW, - S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); - if (fd < 0) { - MYLOGE("%s: %s\n", path, strerror(errno)); - return false; - } - - TEMP_FAILURE_RETRY(dup2(fd, fileno(redirect))); - close(fd); - return true; -} - -bool redirect_to_file(FILE* redirect, char* path) { - return _redirect_to_file(redirect, path, O_TRUNC); -} - -bool redirect_to_existing_file(FILE* redirect, char* path) { - return _redirect_to_file(redirect, path, O_APPEND); -} - -void dump_route_tables() { - DurationReporter duration_reporter("DUMP ROUTE TABLES"); - if (PropertiesHelper::IsDryRun()) return; - const char* const RT_TABLES_PATH = "/data/misc/net/rt_tables"; - ds.DumpFile("RT_TABLES", RT_TABLES_PATH); - FILE* fp = fopen(RT_TABLES_PATH, "re"); - if (!fp) { - printf("*** %s: %s\n", RT_TABLES_PATH, strerror(errno)); - return; - } - char table[16]; - // Each line has an integer (the table number), a space, and a string (the table name). We only - // need the table number. It's a 32-bit unsigned number, so max 10 chars. Skip the table name. - // Add a fixed max limit so this doesn't go awry. - for (int i = 0; i < 64 && fscanf(fp, " %10s %*s", table) == 1; ++i) { - RunCommand("ROUTE TABLE IPv4", {"ip", "-4", "route", "show", "table", table}); - RunCommand("ROUTE TABLE IPv6", {"ip", "-6", "route", "show", "table", table}); - } - fclose(fp); -} - -// TODO: make this function thread safe if sections are generated in parallel. -void Dumpstate::UpdateProgress(int32_t delta_sec) { - if (progress_ == nullptr) { - MYLOGE("UpdateProgress: progress_ not set\n"); - return; - } - - // Always update progess so stats can be tuned... - bool max_changed = progress_->Inc(delta_sec); - - // ...but only notifiy listeners when necessary. - if (!options_->do_progress_updates) return; - - int progress = progress_->Get(); - int max = progress_->GetMax(); - - // adjusts max on the fly - if (max_changed && listener_ != nullptr) { - listener_->onMaxProgressUpdated(max); - } - - int32_t last_update_delta = progress - last_updated_progress_; - if (last_updated_progress_ > 0 && last_update_delta < update_progress_threshold_) { - return; - } - last_updated_progress_ = progress; - - if (control_socket_fd_ >= 0) { - dprintf(control_socket_fd_, "PROGRESS:%d/%d\n", progress, max); - fsync(control_socket_fd_); - } - - int percent = 100 * progress / max; - if (listener_ != nullptr) { - if (percent % 5 == 0) { - // We don't want to spam logcat, so only log multiples of 5. - MYLOGD("Setting progress (%s): %d/%d (%d%%)\n", listener_name_.c_str(), progress, max, - percent); - } else { - // stderr is ignored on normal invocations, but useful when calling - // /system/bin/dumpstate directly for debuggging. - fprintf(stderr, "Setting progress (%s): %d/%d (%d%%)\n", listener_name_.c_str(), - progress, max, percent); - } - // TODO(b/111441001): Remove in favor of onProgress - listener_->onProgressUpdated(progress); - - listener_->onProgress(percent); - } -} - -void Dumpstate::TakeScreenshot(const std::string& path) { - const std::string& real_path = path.empty() ? screenshot_path_ : path; - int status = - RunCommand("", {"/system/bin/screencap", "-p", real_path}, - CommandOptions::WithTimeout(10).Always().DropRoot().RedirectStderr().Build()); - if (status == 0) { - MYLOGD("Screenshot saved on %s\n", real_path.c_str()); - } else { - MYLOGE("Failed to take screenshot on %s\n", real_path.c_str()); - } -} - -bool is_dir(const char* pathname) { - struct stat info; - if (stat(pathname, &info) == -1) { - return false; - } - return S_ISDIR(info.st_mode); -} - -time_t get_mtime(int fd, time_t default_mtime) { - struct stat info; - if (fstat(fd, &info) == -1) { - return default_mtime; - } - return info.st_mtime; -} - -void dump_emmc_ecsd(const char *ext_csd_path) { - // List of interesting offsets - struct hex { - char str[2]; - }; - static const size_t EXT_CSD_REV = 192 * sizeof(hex); - static const size_t EXT_PRE_EOL_INFO = 267 * sizeof(hex); - static const size_t EXT_DEVICE_LIFE_TIME_EST_TYP_A = 268 * sizeof(hex); - static const size_t EXT_DEVICE_LIFE_TIME_EST_TYP_B = 269 * sizeof(hex); - - std::string buffer; - if (!android::base::ReadFileToString(ext_csd_path, &buffer)) { - return; - } - - printf("------ %s Extended CSD ------\n", ext_csd_path); - - if (buffer.length() < (EXT_CSD_REV + sizeof(hex))) { - printf("*** %s: truncated content %zu\n\n", ext_csd_path, buffer.length()); - return; - } - - int ext_csd_rev = 0; - std::string sub = buffer.substr(EXT_CSD_REV, sizeof(hex)); - if (sscanf(sub.c_str(), "%2x", &ext_csd_rev) != 1) { - printf("*** %s: EXT_CSD_REV parse error \"%s\"\n\n", ext_csd_path, sub.c_str()); - return; - } - - static const char *ver_str[] = { - "4.0", "4.1", "4.2", "4.3", "Obsolete", "4.41", "4.5", "5.0" - }; - printf("rev 1.%d (MMC %s)\n", ext_csd_rev, - (ext_csd_rev < (int)(sizeof(ver_str) / sizeof(ver_str[0]))) ? ver_str[ext_csd_rev] - : "Unknown"); - if (ext_csd_rev < 7) { - printf("\n"); - return; - } - - if (buffer.length() < (EXT_PRE_EOL_INFO + sizeof(hex))) { - printf("*** %s: truncated content %zu\n\n", ext_csd_path, buffer.length()); - return; - } - - int ext_pre_eol_info = 0; - sub = buffer.substr(EXT_PRE_EOL_INFO, sizeof(hex)); - if (sscanf(sub.c_str(), "%2x", &ext_pre_eol_info) != 1) { - printf("*** %s: PRE_EOL_INFO parse error \"%s\"\n\n", ext_csd_path, sub.c_str()); - return; - } - - static const char *eol_str[] = { - "Undefined", - "Normal", - "Warning (consumed 80% of reserve)", - "Urgent (consumed 90% of reserve)" - }; - printf( - "PRE_EOL_INFO %d (MMC %s)\n", ext_pre_eol_info, - eol_str[(ext_pre_eol_info < (int)(sizeof(eol_str) / sizeof(eol_str[0]))) ? ext_pre_eol_info - : 0]); - - for (size_t lifetime = EXT_DEVICE_LIFE_TIME_EST_TYP_A; - lifetime <= EXT_DEVICE_LIFE_TIME_EST_TYP_B; - lifetime += sizeof(hex)) { - int ext_device_life_time_est; - static const char *est_str[] = { - "Undefined", - "0-10% of device lifetime used", - "10-20% of device lifetime used", - "20-30% of device lifetime used", - "30-40% of device lifetime used", - "40-50% of device lifetime used", - "50-60% of device lifetime used", - "60-70% of device lifetime used", - "70-80% of device lifetime used", - "80-90% of device lifetime used", - "90-100% of device lifetime used", - "Exceeded the maximum estimated device lifetime", - }; - - if (buffer.length() < (lifetime + sizeof(hex))) { - printf("*** %s: truncated content %zu\n", ext_csd_path, buffer.length()); - break; - } - - ext_device_life_time_est = 0; - sub = buffer.substr(lifetime, sizeof(hex)); - if (sscanf(sub.c_str(), "%2x", &ext_device_life_time_est) != 1) { - printf("*** %s: DEVICE_LIFE_TIME_EST_TYP_%c parse error \"%s\"\n", ext_csd_path, - (unsigned)((lifetime - EXT_DEVICE_LIFE_TIME_EST_TYP_A) / sizeof(hex)) + 'A', - sub.c_str()); - continue; - } - printf("DEVICE_LIFE_TIME_EST_TYP_%c %d (MMC %s)\n", - (unsigned)((lifetime - EXT_DEVICE_LIFE_TIME_EST_TYP_A) / sizeof(hex)) + 'A', - ext_device_life_time_est, - est_str[(ext_device_life_time_est < (int)(sizeof(est_str) / sizeof(est_str[0]))) - ? ext_device_life_time_est - : 0]); - } - - printf("\n"); -} diff --git a/cmds/installd/migrate_legacy_obb_data.sh b/cmds/installd/migrate_legacy_obb_data.sh index 4f8a1ecb56..10756881be 100644 --- a/cmds/installd/migrate_legacy_obb_data.sh +++ b/cmds/installd/migrate_legacy_obb_data.sh @@ -15,6 +15,19 @@ # See the License for the specific language governing permissions and # limitations under the License. +rm -rf /sdcard/Android/obb/test_probe +mkdir -p /sdcard/Android/obb/ +touch /sdcard/Android/obb/test_probe +if ! test -f /data/media/0/Android/obb/test_probe ; then + log -p i -t migrate_legacy_obb_data "No support for 'unshared_obb'. Not migrating" + rm -rf /sdcard/Android/obb/test_probe + exit 0 +fi + +# Delete the test file, and remove the obb folder if it is empty +rm -rf /sdcard/Android/obb/test_probe +rmdir /data/media/obb + if ! test -d /data/media/obb ; then log -p i -t migrate_legacy_obb_data "No legacy obb data to migrate." exit 0 diff --git a/cmds/installd/otapreopt_chroot.cpp b/cmds/installd/otapreopt_chroot.cpp index 0c4badf489..b4bcd53120 100644 --- a/cmds/installd/otapreopt_chroot.cpp +++ b/cmds/installd/otapreopt_chroot.cpp @@ -236,6 +236,18 @@ static int otapreopt_chroot(const int argc, char **arg) { // the Android Runtime APEX, as it is required by otapreopt to run dex2oat. std::vector<apex::ApexFile> active_packages = ActivateApexPackages(); + // Check that an Android Runtime APEX has been activated; clean up and exit + // early otherwise. + if (std::none_of(active_packages.begin(), + active_packages.end(), + [](const apex::ApexFile& package){ + return package.GetManifest().name() == "com.android.runtime"; + })) { + LOG(FATAL_WITHOUT_ABORT) << "No activated com.android.runtime APEX package."; + DeactivateApexPackages(active_packages); + exit(217); + } + // Now go on and run otapreopt. // Incoming: cmd + status-fd + target-slot + cmd... | Incoming | = argc diff --git a/cmds/lshal/Android.bp b/cmds/lshal/Android.bp index 495cc80a5c..f8b8c6841e 100644 --- a/cmds/lshal/Android.bp +++ b/cmds/lshal/Android.bp @@ -36,6 +36,7 @@ cc_library_static { "TableEntry.cpp", "TextTable.cpp", "utils.cpp", + "WaitCommand.cpp", ], cflags: [ "-Wall", diff --git a/cmds/lshal/ListCommand.cpp b/cmds/lshal/ListCommand.cpp index c706d911ec..ad7e4c490f 100644 --- a/cmds/lshal/ListCommand.cpp +++ b/cmds/lshal/ListCommand.cpp @@ -975,7 +975,8 @@ void ListCommand::registerAllOptions() { " - DM: if the HAL is in the device manifest\n" " - DC: if the HAL is in the device compatibility matrix\n" " - FM: if the HAL is in the framework manifest\n" - " - FC: if the HAL is in the framework compatibility matrix"}); + " - FC: if the HAL is in the framework compatibility matrix\n" + " - X: if the HAL is in none of the above lists"}); mOptions.push_back({'S', "service-status", no_argument, v++, [](ListCommand* thiz, const char*) { thiz->mSelectedColumns.push_back(TableColumnType::SERVICE_STATUS); return OK; diff --git a/cmds/lshal/Lshal.cpp b/cmds/lshal/Lshal.cpp index 8c83457d3b..132b31ebc3 100644 --- a/cmds/lshal/Lshal.cpp +++ b/cmds/lshal/Lshal.cpp @@ -26,7 +26,9 @@ #include <hidl/HidlTransportUtils.h> #include "DebugCommand.h" +#include "HelpCommand.h" #include "ListCommand.h" +#include "WaitCommand.h" #include "PipeRelay.h" namespace android { @@ -49,6 +51,7 @@ Lshal::Lshal(std::ostream &out, std::ostream &err, mRegisteredCommands.push_back({std::make_unique<ListCommand>(*this)}); mRegisteredCommands.push_back({std::make_unique<DebugCommand>(*this)}); mRegisteredCommands.push_back({std::make_unique<HelpCommand>(*this)}); + mRegisteredCommands.push_back({std::make_unique<WaitCommand>(*this)}); } void Lshal::forEachCommand(const std::function<void(const Command* c)>& f) const { diff --git a/cmds/lshal/Lshal.h b/cmds/lshal/Lshal.h index 2679650611..830bd872ff 100644 --- a/cmds/lshal/Lshal.h +++ b/cmds/lshal/Lshal.h @@ -24,7 +24,6 @@ #include <utils/StrongPointer.h> #include "Command.h" -#include "HelpCommand.h" #include "NullableOStream.h" #include "utils.h" diff --git a/cmds/lshal/WaitCommand.cpp b/cmds/lshal/WaitCommand.cpp new file mode 100644 index 0000000000..65b41b95d2 --- /dev/null +++ b/cmds/lshal/WaitCommand.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * 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. + */ + +#include "WaitCommand.h" + +#include "Lshal.h" + +#include <hidl/ServiceManagement.h> +#include <hidl-util/FQName.h> + +namespace android { +namespace lshal { + +std::string WaitCommand::getName() const { + return "wait"; +} + +std::string WaitCommand::getSimpleDescription() const { + return "Wait for HAL to start if it is not already started."; +} + +Status WaitCommand::parseArgs(const Arg &arg) { + if (optind + 1 != arg.argc) { + return USAGE; + } + + mInterfaceName = arg.argv[optind]; + ++optind; + return OK; +} + +Status WaitCommand::main(const Arg &arg) { + Status status = parseArgs(arg); + if (status != OK) { + return status; + } + + auto [interface, instance] = splitFirst(mInterfaceName, '/'); + instance = instance.empty() ? "default" : instance; + + FQName fqName; + if (!FQName::parse(interface, &fqName) || fqName.isIdentifier() || !fqName.isFullyQualified()) { + mLshal.err() << "Invalid fully-qualified name '" << interface << "'\n\n"; + return USAGE; + } + + using android::hidl::manager::V1_0::IServiceManager; + + using android::hardware::details::getRawServiceInternal; + auto service = getRawServiceInternal(interface, instance, true /*retry*/, false /*getStub*/); + + if (service == nullptr) { + mLshal.err() << "Service not found (missing permissions or not in VINTF manifest?).\n"; + return NO_INTERFACE; + } + + return OK; +} + +void WaitCommand::usage() const { + static const std::string debug = + "wait:\n" + " lshal wait <interface/instance> \n" + " For a HAL that is on the device, wait for the HAL to start.\n" + " This will not start a HAL unless it is configured as a lazy HAL.\n" + " <interface>: Format is `android.hardware.foo@1.0::IFoo/default`.\n" + " If instance name is missing `default` is used.\n"; + + mLshal.err() << debug; +} + +} // namespace lshal +} // namespace android + diff --git a/cmds/lshal/WaitCommand.h b/cmds/lshal/WaitCommand.h new file mode 100644 index 0000000000..c9f67c2b27 --- /dev/null +++ b/cmds/lshal/WaitCommand.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * 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. + */ + +#pragma once + +#include <string> + +#include <android-base/macros.h> + +#include "Command.h" +#include "utils.h" + +namespace android { +namespace lshal { + +class Lshal; + +class WaitCommand : public Command { +public: + explicit WaitCommand(Lshal &lshal) : Command(lshal) {} + ~WaitCommand() = default; + Status main(const Arg &arg) override; + void usage() const override; + std::string getSimpleDescription() const override; + std::string getName() const override; +private: + Status parseArgs(const Arg &arg); + + std::string mInterfaceName; + + DISALLOW_COPY_AND_ASSIGN(WaitCommand); +}; + + +} // namespace lshal +} // namespace android diff --git a/cmds/service/Android.bp b/cmds/service/Android.bp index 9513ec1c23..a5b1ac5c5f 100644 --- a/cmds/service/Android.bp +++ b/cmds/service/Android.bp @@ -4,6 +4,7 @@ cc_binary { srcs: ["service.cpp"], shared_libs: [ + "libcutils", "libutils", "libbinder", ], @@ -22,6 +23,7 @@ cc_binary { srcs: ["service.cpp"], shared_libs: [ + "libcutils", "libutils", "libbinder", ], diff --git a/cmds/service/service.cpp b/cmds/service/service.cpp index d5dc6b741d..18b6b58a9e 100644 --- a/cmds/service/service.cpp +++ b/cmds/service/service.cpp @@ -18,13 +18,18 @@ #include <binder/ProcessState.h> #include <binder/IServiceManager.h> #include <binder/TextOutput.h> +#include <cutils/ashmem.h> #include <getopt.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <unistd.h> +#include <sys/mman.h> #include <sys/time.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> using namespace android; @@ -70,7 +75,7 @@ int main(int argc, char* const argv[]) { bool wantsUsage = false; int result = 0; - + while (1) { int ic = getopt(argc, argv, "h?"); if (ic < 0) @@ -97,7 +102,7 @@ int main(int argc, char* const argv[]) aerr << "service: Unable to get default service manager!" << endl; return 20; } - + if (optind >= argc) { wantsUsage = true; } else if (!wantsUsage) { @@ -119,8 +124,8 @@ int main(int argc, char* const argv[]) for (unsigned i = 0; i < services.size(); i++) { String16 name = services[i]; sp<IBinder> service = sm->checkService(name); - aout << i - << "\t" << good_old_string(name) + aout << i + << "\t" << good_old_string(name) << ": [" << good_old_string(get_interface_name(service)) << "]" << endl; } @@ -187,69 +192,120 @@ int main(int argc, char* const argv[]) } else if (strcmp(argv[optind], "null") == 0) { optind++; data.writeStrongBinder(nullptr); + } else if (strcmp(argv[optind], "fd") == 0) { + optind++; + if (optind >= argc) { + aerr << "service: no path supplied for 'fd'" << endl; + wantsUsage = true; + result = 10; + break; + } + const char *path = argv[optind++]; + int fd = open(path, O_RDONLY); + if (fd < 0) { + aerr << "service: could not open '" << path << "'" << endl; + wantsUsage = true; + result = 10; + break; + } + data.writeFileDescriptor(fd, true /* take ownership */); + } else if (strcmp(argv[optind], "afd") == 0) { + optind++; + if (optind >= argc) { + aerr << "service: no path supplied for 'afd'" << endl; + wantsUsage = true; + result = 10; + break; + } + const char *path = argv[optind++]; + int fd = open(path, O_RDONLY); + struct stat statbuf; + if (fd < 0 || fstat(fd, &statbuf) != 0) { + aerr << "service: could not open or stat '" << path << "'" << endl; + wantsUsage = true; + result = 10; + break; + } + int afd = ashmem_create_region("test", statbuf.st_size); + void* ptr = mmap(NULL, statbuf.st_size, + PROT_READ | PROT_WRITE, MAP_SHARED, afd, 0); + read(fd, ptr, statbuf.st_size); + close(fd); + data.writeFileDescriptor(afd, true /* take ownership */); + } else if (strcmp(argv[optind], "nfd") == 0) { + optind++; + if (optind >= argc) { + aerr << "service: no file descriptor supplied for 'nfd'" << endl; + wantsUsage = true; + result = 10; + break; + } + data.writeFileDescriptor( + atoi(argv[optind++]), true /* take ownership */); + } else if (strcmp(argv[optind], "intent") == 0) { - - char* action = nullptr; - char* dataArg = nullptr; - char* type = nullptr; - int launchFlags = 0; - char* component = nullptr; - int categoryCount = 0; - char* categories[16]; - - char* context1 = nullptr; - + + char* action = nullptr; + char* dataArg = nullptr; + char* type = nullptr; + int launchFlags = 0; + char* component = nullptr; + int categoryCount = 0; + char* categories[16]; + + char* context1 = nullptr; + optind++; - - while (optind < argc) - { - char* key = strtok_r(argv[optind], "=", &context1); - char* value = strtok_r(nullptr, "=", &context1); - + + while (optind < argc) + { + char* key = strtok_r(argv[optind], "=", &context1); + char* value = strtok_r(nullptr, "=", &context1); + // we have reached the end of the XXX=XXX args. if (key == nullptr) break; - - if (strcmp(key, "action") == 0) - { - action = value; - } - else if (strcmp(key, "data") == 0) - { - dataArg = value; - } - else if (strcmp(key, "type") == 0) - { - type = value; - } - else if (strcmp(key, "launchFlags") == 0) - { - launchFlags = atoi(value); - } - else if (strcmp(key, "component") == 0) - { - component = value; - } - else if (strcmp(key, "categories") == 0) - { - char* context2 = nullptr; - categories[categoryCount] = strtok_r(value, ",", &context2); - - while (categories[categoryCount] != nullptr) - { - categoryCount++; - categories[categoryCount] = strtok_r(nullptr, ",", &context2); - } - } - + + if (strcmp(key, "action") == 0) + { + action = value; + } + else if (strcmp(key, "data") == 0) + { + dataArg = value; + } + else if (strcmp(key, "type") == 0) + { + type = value; + } + else if (strcmp(key, "launchFlags") == 0) + { + launchFlags = atoi(value); + } + else if (strcmp(key, "component") == 0) + { + component = value; + } + else if (strcmp(key, "categories") == 0) + { + char* context2 = nullptr; + categories[categoryCount] = strtok_r(value, ",", &context2); + + while (categories[categoryCount] != nullptr) + { + categoryCount++; + categories[categoryCount] = strtok_r(nullptr, ",", &context2); + } + } + optind++; - } - + } + writeString16(data, action); writeString16(data, dataArg); writeString16(data, type); - data.writeInt32(launchFlags); + data.writeInt32(launchFlags); writeString16(data, component); - + if (categoryCount > 0) { data.writeInt32(categoryCount); @@ -261,10 +317,10 @@ int main(int argc, char* const argv[]) else { data.writeInt32(0); - } - + } + // for now just set the extra field to be null. - data.writeInt32(-1); + data.writeInt32(-1); } else { aerr << "service: unknown option " << argv[optind] << endl; wantsUsage = true; @@ -272,7 +328,7 @@ int main(int argc, char* const argv[]) break; } } - + service->transact(code, data, &reply); aout << "Result: " << reply << endl; } else { @@ -295,23 +351,29 @@ int main(int argc, char* const argv[]) result = 10; } } - + if (wantsUsage) { aout << "Usage: service [-h|-?]\n" " service list\n" " service check SERVICE\n" - " service call SERVICE CODE [i32 N | i64 N | f N | d N | s16 STR ] ...\n" + " service call SERVICE CODE [i32 N | i64 N | f N | d N | s16 STR | null" + " | fd f | nfd n | afd f ] ...\n" "Options:\n" " i32: Write the 32-bit integer N into the send parcel.\n" " i64: Write the 64-bit integer N into the send parcel.\n" " f: Write the 32-bit single-precision number N into the send parcel.\n" " d: Write the 64-bit double-precision number N into the send parcel.\n" - " s16: Write the UTF-16 string STR into the send parcel.\n"; + " s16: Write the UTF-16 string STR into the send parcel.\n" + " null: Write a null binder into the send parcel.\n" + " fd: Write a file descriptor for the file f to the send parcel.\n" + " nfd: Write file descriptor n to the send parcel.\n" + " afd: Write an ashmem file descriptor for a region containing the data from" + " file f to the send parcel.\n"; // " intent: Write and Intent int the send parcel. ARGS can be\n" // " action=STR data=STR type=STR launchFlags=INT component=STR categories=STR[,STR,...]\n"; return result; } - + return result; } diff --git a/cmds/servicemanager/Access.cpp b/cmds/servicemanager/Access.cpp index f4005c4dee..d936dbe3a2 100644 --- a/cmds/servicemanager/Access.cpp +++ b/cmds/servicemanager/Access.cpp @@ -69,7 +69,7 @@ static int auditCallback(void *data, security_class_t /*cls*/, char *buf, size_t return 0; } - snprintf(buf, len, "service=%s pid=%d uid=%d", ad->name.c_str(), ad->debugPid, ad->uid); + snprintf(buf, len, "pid=%d uid=%d", ad->debugPid, ad->uid); return 0; } @@ -91,7 +91,7 @@ Access::~Access() { freecon(mThisProcessContext); } -Access::CallingContext Access::getCallingContext(const std::string& name) { +Access::CallingContext Access::getCallingContext() { IPCThreadState* ipc = IPCThreadState::self(); const char* callingSid = ipc->getCallingSid(); @@ -101,21 +101,18 @@ Access::CallingContext Access::getCallingContext(const std::string& name) { .debugPid = callingPid, .uid = ipc->getCallingUid(), .sid = callingSid ? std::string(callingSid) : getPidcon(callingPid), - .name = name, }; } -bool Access::canFind(const CallingContext& ctx) { - return actionAllowedFromLookup(ctx, "find"); +bool Access::canFind(const CallingContext& ctx,const std::string& name) { + return actionAllowedFromLookup(ctx, name, "find"); } -bool Access::canAdd(const CallingContext& ctx) { - return actionAllowedFromLookup(ctx, "add"); +bool Access::canAdd(const CallingContext& ctx, const std::string& name) { + return actionAllowedFromLookup(ctx, name, "add"); } bool Access::canList(const CallingContext& ctx) { - CHECK(ctx.name == ""); - return actionAllowed(ctx, mThisProcessContext, "list"); } @@ -125,10 +122,10 @@ bool Access::actionAllowed(const CallingContext& sctx, const char* tctx, const c return 0 == selinux_check_access(sctx.sid.c_str(), tctx, tclass, perm, reinterpret_cast<void*>(const_cast<CallingContext*>((&sctx)))); } -bool Access::actionAllowedFromLookup(const CallingContext& sctx, const char *perm) { +bool Access::actionAllowedFromLookup(const CallingContext& sctx, const std::string& name, const char *perm) { char *tctx = nullptr; - if (selabel_lookup(getSehandle(), &tctx, sctx.name.c_str(), 0) != 0) { - LOG(ERROR) << "SELinux: No match for " << sctx.name << " in service_contexts.\n"; + if (selabel_lookup(getSehandle(), &tctx, name.c_str(), 0) != 0) { + LOG(ERROR) << "SELinux: No match for " << name << " in service_contexts.\n"; return false; } diff --git a/cmds/servicemanager/Access.h b/cmds/servicemanager/Access.h index b2c78cc34d..05a60d33f1 100644 --- a/cmds/servicemanager/Access.h +++ b/cmds/servicemanager/Access.h @@ -36,22 +36,18 @@ public: pid_t debugPid; uid_t uid; std::string sid; - - // name of the service - // - // empty if call is unrelated to service (e.g. list) - std::string name; }; - virtual CallingContext getCallingContext(const std::string& name); + virtual CallingContext getCallingContext(); - virtual bool canFind(const CallingContext& ctx); - virtual bool canAdd(const CallingContext& ctx); + virtual bool canFind(const CallingContext& ctx, const std::string& name); + virtual bool canAdd(const CallingContext& ctx, const std::string& name); virtual bool canList(const CallingContext& ctx); private: bool actionAllowed(const CallingContext& sctx, const char* tctx, const char* perm); - bool actionAllowedFromLookup(const CallingContext& sctx, const char *perm); + bool actionAllowedFromLookup(const CallingContext& sctx, const std::string& name, + const char *perm); char* mThisProcessContext = nullptr; }; diff --git a/cmds/servicemanager/ServiceManager.cpp b/cmds/servicemanager/ServiceManager.cpp index b88b67d138..c2c71e0770 100644 --- a/cmds/servicemanager/ServiceManager.cpp +++ b/cmds/servicemanager/ServiceManager.cpp @@ -32,7 +32,7 @@ Status ServiceManager::getService(const std::string& name, sp<IBinder>* outBinde } Status ServiceManager::checkService(const std::string& name, sp<IBinder>* outBinder) { - auto ctx = mAccess->getCallingContext(name); + auto ctx = mAccess->getCallingContext(); auto it = mNameToService.find(name); if (it == mNameToService.end()) { @@ -53,7 +53,7 @@ Status ServiceManager::checkService(const std::string& name, sp<IBinder>* outBin } // TODO(b/136023468): move this check to be first - if (!mAccess->canFind(ctx)) { + if (!mAccess->canFind(ctx, name)) { // returns ok and null for legacy reasons *outBinder = nullptr; return Status::ok(); @@ -63,15 +63,30 @@ Status ServiceManager::checkService(const std::string& name, sp<IBinder>* outBin return Status::ok(); } +bool isValidServiceName(const std::string& name) { + if (name.size() == 0) return false; + if (name.size() > 127) return false; + + for (char c : name) { + if (c == '_' || c == '-' || c == '.') continue; + if (c >= 'a' && c <= 'z') continue; + if (c >= 'A' && c <= 'Z') continue; + if (c >= '0' && c <= '9') continue; + return false; + } + + return true; +} + Status ServiceManager::addService(const std::string& name, const sp<IBinder>& binder, bool allowIsolated, int32_t dumpPriority) { - auto ctx = mAccess->getCallingContext(name); + auto ctx = mAccess->getCallingContext(); // apps cannot add services if (multiuser_get_app_id(ctx.uid) >= AID_APP) { return Status::fromExceptionCode(Status::EX_SECURITY); } - if (!mAccess->canAdd(ctx)) { + if (!mAccess->canAdd(ctx, name)) { return Status::fromExceptionCode(Status::EX_SECURITY); } @@ -79,8 +94,8 @@ Status ServiceManager::addService(const std::string& name, const sp<IBinder>& bi return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT); } - // match legacy rules - if (name.size() == 0 || name.size() > 127) { + if (!isValidServiceName(name)) { + LOG(ERROR) << "Invalid service name: " << name; return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT); } @@ -106,7 +121,7 @@ Status ServiceManager::addService(const std::string& name, const sp<IBinder>& bi } Status ServiceManager::listServices(int32_t dumpPriority, std::vector<std::string>* outList) { - if (!mAccess->canList(mAccess->getCallingContext(""))) { + if (!mAccess->canList(mAccess->getCallingContext())) { return Status::fromExceptionCode(Status::EX_SECURITY); } diff --git a/cmds/servicemanager/TEST_MAPPING b/cmds/servicemanager/TEST_MAPPING index 3e47269fe0..739740aa21 100644 --- a/cmds/servicemanager/TEST_MAPPING +++ b/cmds/servicemanager/TEST_MAPPING @@ -3,5 +3,10 @@ { "name": "servicemanager_test" } + ], + "imports": [ + { + "path": "frameworks/native/libs/binder" + } ] } diff --git a/cmds/servicemanager/main.cpp b/cmds/servicemanager/main.cpp index c8ceb42ac8..9f6193b97a 100644 --- a/cmds/servicemanager/main.cpp +++ b/cmds/servicemanager/main.cpp @@ -38,14 +38,13 @@ int main(int argc, char** argv) { android::base::InitLogging(nullptr, &android::base::KernelLogger); - ProcessState::self()->initWithDriver(driver); - ProcessState::self()->setThreadPoolMaxThreadCount(0); - ProcessState::self()->setCallRestriction( - ProcessState::CallRestriction::FATAL_IF_NOT_ONEWAY); + sp<ProcessState> ps = ProcessState::initWithDriver(driver); + ps->setThreadPoolMaxThreadCount(0); + ps->setCallRestriction(ProcessState::CallRestriction::FATAL_IF_NOT_ONEWAY); sp<ServiceManager> manager = new ServiceManager(std::make_unique<Access>()); IPCThreadState::self()->setTheContextObject(manager); - ProcessState::self()->becomeContextManager(nullptr, nullptr); + ps->becomeContextManager(nullptr, nullptr); IPCThreadState::self()->joinThreadPool(); diff --git a/cmds/servicemanager/test_sm.cpp b/cmds/servicemanager/test_sm.cpp index 812d5cacd5..91485e456b 100644 --- a/cmds/servicemanager/test_sm.cpp +++ b/cmds/servicemanager/test_sm.cpp @@ -40,18 +40,18 @@ static sp<IBinder> getBinder() { class MockAccess : public Access { public: - MOCK_METHOD1(getCallingContext, CallingContext(const std::string& name)); - MOCK_METHOD1(canAdd, bool(const CallingContext&)); - MOCK_METHOD1(canFind, bool(const CallingContext&)); + MOCK_METHOD0(getCallingContext, CallingContext()); + MOCK_METHOD2(canAdd, bool(const CallingContext&, const std::string& name)); + MOCK_METHOD2(canFind, bool(const CallingContext&, const std::string& name)); MOCK_METHOD1(canList, bool(const CallingContext&)); }; static sp<ServiceManager> getPermissiveServiceManager() { std::unique_ptr<MockAccess> access = std::make_unique<NiceMock<MockAccess>>(); - ON_CALL(*access, getCallingContext(_)).WillByDefault(Return(Access::CallingContext{})); - ON_CALL(*access, canAdd(_)).WillByDefault(Return(true)); - ON_CALL(*access, canFind(_)).WillByDefault(Return(true)); + ON_CALL(*access, getCallingContext()).WillByDefault(Return(Access::CallingContext{})); + ON_CALL(*access, canAdd(_, _)).WillByDefault(Return(true)); + ON_CALL(*access, canFind(_, _)).WillByDefault(Return(true)); ON_CALL(*access, canList(_)).WillByDefault(Return(true)); sp<ServiceManager> sm = new ServiceManager(std::move(access)); @@ -82,6 +82,12 @@ TEST(AddService, TooLongNameDisallowed) { IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT).isOk()); } +TEST(AddService, WeirdCharactersDisallowed) { + auto sm = getPermissiveServiceManager(); + EXPECT_FALSE(sm->addService("happy$foo$foo", getBinder(), false /*allowIsolated*/, + IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT).isOk()); +} + TEST(AddService, AddNullServiceDisallowed) { auto sm = getPermissiveServiceManager(); EXPECT_FALSE(sm->addService("foo", nullptr, false /*allowIsolated*/, @@ -91,11 +97,11 @@ TEST(AddService, AddNullServiceDisallowed) { TEST(AddService, AddDisallowedFromApp) { for (uid_t uid : { AID_APP_START, AID_APP_START + 1, AID_APP_END }) { std::unique_ptr<MockAccess> access = std::make_unique<NiceMock<MockAccess>>(); - EXPECT_CALL(*access, getCallingContext(_)).WillOnce(Return(Access::CallingContext{ + EXPECT_CALL(*access, getCallingContext()).WillOnce(Return(Access::CallingContext{ .debugPid = 1337, .uid = uid, })); - EXPECT_CALL(*access, canAdd(_)).Times(0); + EXPECT_CALL(*access, canAdd(_, _)).Times(0); sp<ServiceManager> sm = new ServiceManager(std::move(access)); EXPECT_FALSE(sm->addService("foo", getBinder(), false /*allowIsolated*/, @@ -115,8 +121,8 @@ TEST(AddService, HappyOverExistingService) { TEST(AddService, NoPermissions) { std::unique_ptr<MockAccess> access = std::make_unique<NiceMock<MockAccess>>(); - EXPECT_CALL(*access, getCallingContext(_)).WillOnce(Return(Access::CallingContext{})); - EXPECT_CALL(*access, canAdd(_)).WillOnce(Return(false)); + EXPECT_CALL(*access, getCallingContext()).WillOnce(Return(Access::CallingContext{})); + EXPECT_CALL(*access, canAdd(_, _)).WillOnce(Return(false)); sp<ServiceManager> sm = new ServiceManager(std::move(access)); @@ -145,9 +151,9 @@ TEST(GetService, NonExistant) { TEST(GetService, NoPermissionsForGettingService) { std::unique_ptr<MockAccess> access = std::make_unique<NiceMock<MockAccess>>(); - EXPECT_CALL(*access, getCallingContext(_)).WillRepeatedly(Return(Access::CallingContext{})); - EXPECT_CALL(*access, canAdd(_)).WillOnce(Return(true)); - EXPECT_CALL(*access, canFind(_)).WillOnce(Return(false)); + EXPECT_CALL(*access, getCallingContext()).WillRepeatedly(Return(Access::CallingContext{})); + EXPECT_CALL(*access, canAdd(_, _)).WillOnce(Return(true)); + EXPECT_CALL(*access, canFind(_, _)).WillOnce(Return(false)); sp<ServiceManager> sm = new ServiceManager(std::move(access)); @@ -163,15 +169,15 @@ TEST(GetService, NoPermissionsForGettingService) { TEST(GetService, AllowedFromIsolated) { std::unique_ptr<MockAccess> access = std::make_unique<NiceMock<MockAccess>>(); - EXPECT_CALL(*access, getCallingContext(_)) + EXPECT_CALL(*access, getCallingContext()) // something adds it .WillOnce(Return(Access::CallingContext{})) // next call is from isolated app .WillOnce(Return(Access::CallingContext{ .uid = AID_ISOLATED_START, })); - EXPECT_CALL(*access, canAdd(_)).WillOnce(Return(true)); - EXPECT_CALL(*access, canFind(_)).WillOnce(Return(true)); + EXPECT_CALL(*access, canAdd(_, _)).WillOnce(Return(true)); + EXPECT_CALL(*access, canFind(_, _)).WillOnce(Return(true)); sp<ServiceManager> sm = new ServiceManager(std::move(access)); @@ -186,17 +192,17 @@ TEST(GetService, AllowedFromIsolated) { TEST(GetService, NotAllowedFromIsolated) { std::unique_ptr<MockAccess> access = std::make_unique<NiceMock<MockAccess>>(); - EXPECT_CALL(*access, getCallingContext(_)) + EXPECT_CALL(*access, getCallingContext()) // something adds it .WillOnce(Return(Access::CallingContext{})) // next call is from isolated app .WillOnce(Return(Access::CallingContext{ .uid = AID_ISOLATED_START, })); - EXPECT_CALL(*access, canAdd(_)).WillOnce(Return(true)); + EXPECT_CALL(*access, canAdd(_, _)).WillOnce(Return(true)); // TODO(b/136023468): when security check is first, this should be called first - // EXPECT_CALL(*access, canFind(_)).WillOnce(Return(true)); + // EXPECT_CALL(*access, canFind(_, _)).WillOnce(Return(true)); sp<ServiceManager> sm = new ServiceManager(std::move(access)); @@ -212,7 +218,7 @@ TEST(GetService, NotAllowedFromIsolated) { TEST(ListServices, NoPermissions) { std::unique_ptr<MockAccess> access = std::make_unique<NiceMock<MockAccess>>(); - EXPECT_CALL(*access, getCallingContext(_)).WillOnce(Return(Access::CallingContext{})); + EXPECT_CALL(*access, getCallingContext()).WillOnce(Return(Access::CallingContext{})); EXPECT_CALL(*access, canList(_)).WillOnce(Return(false)); sp<ServiceManager> sm = new ServiceManager(std::move(access)); diff --git a/cmds/surfacereplayer/proto/src/trace.proto b/cmds/surfacereplayer/proto/src/trace.proto index c70bc3e5c1..a738527fbb 100644 --- a/cmds/surfacereplayer/proto/src/trace.proto +++ b/cmds/surfacereplayer/proto/src/trace.proto @@ -46,6 +46,10 @@ message SurfaceChange { SecureFlagChange secure_flag = 14; DeferredTransactionChange deferred_transaction = 15; CornerRadiusChange corner_radius = 16; + ReparentChange reparent = 17; + RelativeParentChange relative_parent = 18; + DetachChildrenChange detach_children = 19; + ReparentChildrenChange reparent_children = 20; } } @@ -177,3 +181,20 @@ message PowerModeUpdate { required int32 id = 1; required int32 mode = 2; } + +message ReparentChange { + required int32 parent_id = 1; +} + +message ReparentChildrenChange { + required int32 parent_id = 1; +} + +message RelativeParentChange { + required int32 relative_parent_id = 1; + required int32 z = 2; +} + +message DetachChildrenChange { + required bool detach_children = 1; +} diff --git a/cmds/surfacereplayer/replayer/Replayer.cpp b/cmds/surfacereplayer/replayer/Replayer.cpp index 34886a99e9..a4a9b6a6f4 100644 --- a/cmds/surfacereplayer/replayer/Replayer.cpp +++ b/cmds/surfacereplayer/replayer/Replayer.cpp @@ -412,6 +412,18 @@ status_t Replayer::doSurfaceTransaction( setDeferredTransaction(transaction, change.id(), change.deferred_transaction()); break; + case SurfaceChange::SurfaceChangeCase::kReparent: + setReparentChange(transaction, change.id(), change.reparent()); + break; + case SurfaceChange::SurfaceChangeCase::kReparentChildren: + setReparentChildrenChange(transaction, change.id(), change.reparent_children()); + break; + case SurfaceChange::SurfaceChangeCase::kRelativeParent: + setRelativeParentChange(transaction, change.id(), change.relative_parent()); + break; + case SurfaceChange::SurfaceChangeCase::kDetachChildren: + setDetachChildrenChange(transaction, change.id(), change.detach_children()); + break; default: status = 1; break; @@ -680,3 +692,35 @@ status_t Replayer::loadSurfaceComposerClient() { mComposerClient = new SurfaceComposerClient; return mComposerClient->initCheck(); } + +void Replayer::setReparentChange(SurfaceComposerClient::Transaction& t, + layer_id id, const ReparentChange& c) { + sp<IBinder> newParentHandle = nullptr; + if (mLayers.count(c.parent_id()) != 0 && mLayers[c.parent_id()] != nullptr) { + newParentHandle = mLayers[c.parent_id()]->getHandle(); + } + t.reparent(mLayers[id], newParentHandle); +} + +void Replayer::setRelativeParentChange(SurfaceComposerClient::Transaction& t, + layer_id id, const RelativeParentChange& c) { + if (mLayers.count(c.relative_parent_id()) == 0 || mLayers[c.relative_parent_id()] == nullptr) { + ALOGE("Layer %d not found in set relative parent transaction", c.relative_parent_id()); + return; + } + t.setRelativeLayer(mLayers[id], mLayers[c.relative_parent_id()]->getHandle(), c.z()); +} + +void Replayer::setDetachChildrenChange(SurfaceComposerClient::Transaction& t, + layer_id id, const DetachChildrenChange& c) { + t.detachChildren(mLayers[id]); +} + +void Replayer::setReparentChildrenChange(SurfaceComposerClient::Transaction& t, + layer_id id, const ReparentChildrenChange& c) { + if (mLayers.count(c.parent_id()) == 0 || mLayers[c.parent_id()] == nullptr) { + ALOGE("Layer %d not found in reparent children transaction", c.parent_id()); + return; + } + t.reparentChildren(mLayers[id], mLayers[c.parent_id()]->getHandle()); +} diff --git a/cmds/surfacereplayer/replayer/Replayer.h b/cmds/surfacereplayer/replayer/Replayer.h index ad807ee950..d7709cc211 100644 --- a/cmds/surfacereplayer/replayer/Replayer.h +++ b/cmds/surfacereplayer/replayer/Replayer.h @@ -108,6 +108,14 @@ class Replayer { layer_id id, const SecureFlagChange& sfc); void setDeferredTransaction(SurfaceComposerClient::Transaction& t, layer_id id, const DeferredTransactionChange& dtc); + void setReparentChange(SurfaceComposerClient::Transaction& t, + layer_id id, const ReparentChange& c); + void setRelativeParentChange(SurfaceComposerClient::Transaction& t, + layer_id id, const RelativeParentChange& c); + void setDetachChildrenChange(SurfaceComposerClient::Transaction& t, + layer_id id, const DetachChildrenChange& c); + void setReparentChildrenChange(SurfaceComposerClient::Transaction& t, + layer_id id, const ReparentChildrenChange& c); void setDisplaySurface(SurfaceComposerClient::Transaction& t, display_id id, const DispSurfaceChange& dsc); diff --git a/libs/binder/Android.bp b/libs/binder/Android.bp index 760d55b751..b23094396c 100644 --- a/libs/binder/Android.bp +++ b/libs/binder/Android.bp @@ -73,7 +73,6 @@ cc_library_shared { "Status.cpp", "TextOutput.cpp", "IpPrefix.cpp", - "Value.cpp", ":libbinder_aidl", ], @@ -115,7 +114,6 @@ cc_library_shared { }, shared_libs: [ - "libbase", "liblog", "libcutils", "libutils", diff --git a/libs/binder/Binder.cpp b/libs/binder/Binder.cpp index cb0e08d123..bdf0f8ef9f 100644 --- a/libs/binder/Binder.cpp +++ b/libs/binder/Binder.cpp @@ -128,7 +128,7 @@ status_t BBinder::transact( status_t err = NO_ERROR; switch (code) { case PING_TRANSACTION: - reply->writeInt32(pingBinder()); + err = pingBinder(); break; default: err = onTransact(code, data, reply, flags); diff --git a/libs/binder/BpBinder.cpp b/libs/binder/BpBinder.cpp index 67f968aea0..5ceb218b8b 100644 --- a/libs/binder/BpBinder.cpp +++ b/libs/binder/BpBinder.cpp @@ -148,6 +148,10 @@ BpBinder::BpBinder(int32_t handle, int32_t trackedUid) IPCThreadState::self()->incWeakHandle(handle, this); } +int32_t BpBinder::handle() const { + return mHandle; +} + bool BpBinder::isDescriptorCached() const { Mutex::Autolock _l(mLock); return mDescriptorCache.size() ? true : false; @@ -186,10 +190,7 @@ status_t BpBinder::pingBinder() { Parcel send; Parcel reply; - status_t err = transact(PING_TRANSACTION, send, &reply); - if (err != NO_ERROR) return err; - if (reply.dataSize() < sizeof(status_t)) return NOT_ENOUGH_DATA; - return (status_t)reply.readInt32(); + return transact(PING_TRANSACTION, send, &reply); } status_t BpBinder::dump(int fd, const Vector<String16>& args) diff --git a/libs/binder/BufferedTextOutput.cpp b/libs/binder/BufferedTextOutput.cpp index 857bbf9510..a7d52409f6 100644 --- a/libs/binder/BufferedTextOutput.cpp +++ b/libs/binder/BufferedTextOutput.cpp @@ -23,12 +23,12 @@ #include <utils/RefBase.h> #include <utils/Vector.h> -#include <private/binder/Static.h> - #include <pthread.h> #include <stdio.h> #include <stdlib.h> +#include "Static.h" + // --------------------------------------------------------------------------- namespace android { diff --git a/libs/binder/IAppOpsCallback.cpp b/libs/binder/IAppOpsCallback.cpp index aba49673b1..4c151e7a65 100644 --- a/libs/binder/IAppOpsCallback.cpp +++ b/libs/binder/IAppOpsCallback.cpp @@ -22,8 +22,6 @@ #include <binder/Parcel.h> #include <utils/String8.h> -#include <private/binder/Static.h> - namespace android { // ---------------------------------------------------------------------- diff --git a/libs/binder/IAppOpsService.cpp b/libs/binder/IAppOpsService.cpp index 66d6e31902..c426f3a31f 100644 --- a/libs/binder/IAppOpsService.cpp +++ b/libs/binder/IAppOpsService.cpp @@ -22,8 +22,6 @@ #include <binder/Parcel.h> #include <utils/String8.h> -#include <private/binder/Static.h> - namespace android { // ---------------------------------------------------------------------- diff --git a/libs/binder/IBatteryStats.cpp b/libs/binder/IBatteryStats.cpp index b307e3e7b5..cc0022a875 100644 --- a/libs/binder/IBatteryStats.cpp +++ b/libs/binder/IBatteryStats.cpp @@ -20,8 +20,6 @@ #include <binder/Parcel.h> #include <utils/String8.h> -#include <private/binder/Static.h> - namespace android { // ---------------------------------------------------------------------- diff --git a/libs/binder/IPCThreadState.cpp b/libs/binder/IPCThreadState.cpp index 3424c28883..cfb86f021c 100644 --- a/libs/binder/IPCThreadState.cpp +++ b/libs/binder/IPCThreadState.cpp @@ -31,7 +31,6 @@ #include <utils/threads.h> #include <private/binder/binder_module.h> -#include <private/binder/Static.h> #include <atomic> #include <errno.h> @@ -44,6 +43,8 @@ #include <sys/resource.h> #include <unistd.h> +#include "Static.h" + #if LOG_NDEBUG #define IF_LOG_TRANSACTIONS() if (false) @@ -998,7 +999,7 @@ status_t IPCThreadState::talkWithDriver(bool doReceive) if (err >= NO_ERROR) { if (bwr.write_consumed > 0) { if (bwr.write_consumed < mOut.dataSize()) - mOut.remove(0, bwr.write_consumed); + LOG_ALWAYS_FATAL("Driver did not consume write buffer"); else { mOut.setDataSize(0); processPostWriteDerefs(); diff --git a/libs/binder/IPermissionController.cpp b/libs/binder/IPermissionController.cpp index 6b99150edf..bf2f20aa0b 100644 --- a/libs/binder/IPermissionController.cpp +++ b/libs/binder/IPermissionController.cpp @@ -22,8 +22,6 @@ #include <binder/Parcel.h> #include <utils/String8.h> -#include <private/binder/Static.h> - namespace android { // ---------------------------------------------------------------------- diff --git a/libs/binder/IResultReceiver.cpp b/libs/binder/IResultReceiver.cpp index 159763d5bf..1e11941023 100644 --- a/libs/binder/IResultReceiver.cpp +++ b/libs/binder/IResultReceiver.cpp @@ -22,8 +22,6 @@ #include <binder/Parcel.h> #include <utils/String8.h> -#include <private/binder/Static.h> - namespace android { // ---------------------------------------------------------------------- diff --git a/libs/binder/IServiceManager.cpp b/libs/binder/IServiceManager.cpp index 07550fb571..74f1f47c7a 100644 --- a/libs/binder/IServiceManager.cpp +++ b/libs/binder/IServiceManager.cpp @@ -29,7 +29,7 @@ #include <utils/String8.h> #include <utils/SystemClock.h> -#include <private/binder/Static.h> +#include "Static.h" #include <unistd.h> diff --git a/libs/binder/IShellCallback.cpp b/libs/binder/IShellCallback.cpp index 6c697decca..88cc603b6f 100644 --- a/libs/binder/IShellCallback.cpp +++ b/libs/binder/IShellCallback.cpp @@ -25,8 +25,6 @@ #include <binder/Parcel.h> #include <utils/String8.h> -#include <private/binder/Static.h> - namespace android { // ---------------------------------------------------------------------- diff --git a/libs/binder/Parcel.cpp b/libs/binder/Parcel.cpp index c389d18243..b5fbf42ffc 100644 --- a/libs/binder/Parcel.cpp +++ b/libs/binder/Parcel.cpp @@ -37,7 +37,6 @@ #include <binder/ProcessState.h> #include <binder/Status.h> #include <binder/TextOutput.h> -#include <binder/Value.h> #include <cutils/ashmem.h> #include <utils/Debug.h> @@ -48,7 +47,7 @@ #include <utils/String16.h> #include <private/binder/binder_module.h> -#include <private/binder/Static.h> +#include "Static.h" #ifndef INT32_MAX #define INT32_MAX ((int32_t)(2147483647)) @@ -667,11 +666,6 @@ bool Parcel::enforceInterface(const String16& interface, } } -const binder_size_t* Parcel::objects() const -{ - return mObjects; -} - size_t Parcel::objectsCount() const { return mObjectsSize; @@ -1163,10 +1157,6 @@ status_t Parcel::writeParcelable(const Parcelable& parcelable) { return parcelable.writeToParcel(this); } -status_t Parcel::writeValue(const binder::Value& value) { - return value.writeToParcel(this); -} - status_t Parcel::writeNativeHandle(const native_handle* handle) { if (!handle || handle->version != sizeof(native_handle)) @@ -1404,125 +1394,6 @@ status_t Parcel::writeNoException() return status.writeToParcel(this); } -status_t Parcel::writeMap(const ::android::binder::Map& map_in) -{ - using ::std::map; - using ::android::binder::Value; - using ::android::binder::Map; - - Map::const_iterator iter; - status_t ret; - - ret = writeInt32(map_in.size()); - - if (ret != NO_ERROR) { - return ret; - } - - for (iter = map_in.begin(); iter != map_in.end(); ++iter) { - ret = writeValue(Value(iter->first)); - if (ret != NO_ERROR) { - return ret; - } - - ret = writeValue(iter->second); - if (ret != NO_ERROR) { - return ret; - } - } - - return ret; -} - -status_t Parcel::writeNullableMap(const std::unique_ptr<binder::Map>& map) -{ - if (map == nullptr) { - return writeInt32(-1); - } - - return writeMap(*map.get()); -} - -status_t Parcel::readMap(::android::binder::Map* map_out)const -{ - using ::std::map; - using ::android::String16; - using ::android::String8; - using ::android::binder::Value; - using ::android::binder::Map; - - status_t ret = NO_ERROR; - int32_t count; - - ret = readInt32(&count); - if (ret != NO_ERROR) { - return ret; - } - - if (count < 0) { - ALOGE("readMap: Unexpected count: %d", count); - return (count == -1) - ? UNEXPECTED_NULL - : BAD_VALUE; - } - - map_out->clear(); - - while (count--) { - Map::key_type key; - Value value; - - ret = readValue(&value); - if (ret != NO_ERROR) { - return ret; - } - - if (!value.getString(&key)) { - ALOGE("readMap: Key type not a string (parcelType = %d)", value.parcelType()); - return BAD_VALUE; - } - - ret = readValue(&value); - if (ret != NO_ERROR) { - return ret; - } - - (*map_out)[key] = value; - } - - return ret; -} - -status_t Parcel::readNullableMap(std::unique_ptr<binder::Map>* map) const -{ - const size_t start = dataPosition(); - int32_t count; - status_t status = readInt32(&count); - map->reset(); - - if (status != OK || count == -1) { - return status; - } - - setDataPosition(start); - map->reset(new binder::Map()); - - status = readMap(map->get()); - - if (status != OK) { - map->reset(); - } - - return status; -} - - - -void Parcel::remove(size_t /*start*/, size_t /*amt*/) -{ - LOG_ALWAYS_FATAL("Parcel::remove() not yet implemented!"); -} - status_t Parcel::validateReadData(size_t upperBound) const { // Don't allow non-object reads on object data @@ -2227,10 +2098,6 @@ status_t Parcel::readParcelable(Parcelable* parcelable) const { return parcelable->readFromParcel(this); } -status_t Parcel::readValue(binder::Value* value) const { - return value->readFromParcel(this); -} - int32_t Parcel::readExceptionCode() const { binder::Status status; @@ -2582,7 +2449,7 @@ void Parcel::print(TextOutput& to, uint32_t /*flags*/) const } else if (dataSize() > 0) { const uint8_t* DATA = data(); to << indent << HexDump(DATA, dataSize()) << dedent; - const binder_size_t* OBJS = objects(); + const binder_size_t* OBJS = mObjects; const size_t N = objectsCount(); for (size_t i=0; i<N; i++) { const flat_binder_object* flat diff --git a/libs/binder/include/private/binder/ParcelValTypes.h b/libs/binder/ParcelValTypes.h index 666d22a57f..666d22a57f 100644 --- a/libs/binder/include/private/binder/ParcelValTypes.h +++ b/libs/binder/ParcelValTypes.h diff --git a/libs/binder/PersistableBundle.cpp b/libs/binder/PersistableBundle.cpp index c0aec0a979..97a6c94635 100644 --- a/libs/binder/PersistableBundle.cpp +++ b/libs/binder/PersistableBundle.cpp @@ -17,7 +17,6 @@ #define LOG_TAG "PersistableBundle" #include <binder/PersistableBundle.h> -#include <private/binder/ParcelValTypes.h> #include <limits> @@ -26,6 +25,8 @@ #include <log/log.h> #include <utils/Errors.h> +#include "ParcelValTypes.h" + using android::BAD_TYPE; using android::BAD_VALUE; using android::NO_ERROR; diff --git a/libs/binder/ProcessState.cpp b/libs/binder/ProcessState.cpp index b25cd7bf12..a07b3a043b 100644 --- a/libs/binder/ProcessState.cpp +++ b/libs/binder/ProcessState.cpp @@ -24,11 +24,10 @@ #include <cutils/atomic.h> #include <utils/Log.h> #include <utils/String8.h> -#include <utils/String8.h> #include <utils/threads.h> #include <private/binder/binder_module.h> -#include <private/binder/Static.h> +#include "Static.h" #include <errno.h> #include <fcntl.h> @@ -40,7 +39,7 @@ #include <sys/stat.h> #include <sys/types.h> -#define DEFAULT_BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2) +#define BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2) #define DEFAULT_MAX_BINDER_THREADS 15 #ifdef __ANDROID_VNDK__ @@ -77,13 +76,7 @@ sp<ProcessState> ProcessState::self() if (gProcess != nullptr) { return gProcess; } - gProcess = new ProcessState(kDefaultDriver, DEFAULT_BINDER_VM_SIZE); - return gProcess; -} - -sp<ProcessState> ProcessState::selfOrNull() -{ - Mutex::Autolock _l(gProcessMutex); + gProcess = new ProcessState(kDefaultDriver); return gProcess; } @@ -104,74 +97,21 @@ sp<ProcessState> ProcessState::initWithDriver(const char* driver) driver = "/dev/binder"; } - gProcess = new ProcessState(driver, DEFAULT_BINDER_VM_SIZE); + gProcess = new ProcessState(driver); return gProcess; } -sp<ProcessState> ProcessState::initWithMmapSize(size_t mmap_size) { +sp<ProcessState> ProcessState::selfOrNull() +{ Mutex::Autolock _l(gProcessMutex); - if (gProcess != nullptr) { - LOG_ALWAYS_FATAL_IF(mmap_size != gProcess->getMmapSize(), - "ProcessState already initialized with a different mmap size."); - return gProcess; - } - - gProcess = new ProcessState(kDefaultDriver, mmap_size); return gProcess; } -void ProcessState::setContextObject(const sp<IBinder>& object) -{ - setContextObject(object, String16("default")); -} - sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/) { return getStrongProxyForHandle(0); } -void ProcessState::setContextObject(const sp<IBinder>& object, const String16& name) -{ - AutoMutex _l(mLock); - mContexts.add(name, object); -} - -sp<IBinder> ProcessState::getContextObject(const String16& name, const sp<IBinder>& caller) -{ - mLock.lock(); - sp<IBinder> object( - mContexts.indexOfKey(name) >= 0 ? mContexts.valueFor(name) : nullptr); - mLock.unlock(); - - //printf("Getting context object %s for %p\n", String8(name).string(), caller.get()); - - if (object != nullptr) return object; - - // Don't attempt to retrieve contexts if we manage them - if (mManagesContexts) { - ALOGE("getContextObject(%s) failed, but we manage the contexts!\n", - String8(name).string()); - return nullptr; - } - - IPCThreadState* ipc = IPCThreadState::self(); - { - Parcel data, reply; - // no interface token on this magic transaction - data.writeString16(name); - data.writeStrongBinder(caller); - status_t result = ipc->transact(0 /*magic*/, 0, data, &reply, 0); - if (result == NO_ERROR) { - object = reply.readStrongBinder(); - } - } - - ipc->flushCommands(); - - if (object != nullptr) setContextObject(object, name); - return object; -} - void ProcessState::startThreadPool() { AutoMutex _l(mLock); @@ -181,41 +121,33 @@ void ProcessState::startThreadPool() } } -bool ProcessState::isContextManager(void) const -{ - return mManagesContexts; -} - bool ProcessState::becomeContextManager(context_check_func checkFunc, void* userData) { - if (!mManagesContexts) { - AutoMutex _l(mLock); - mBinderContextCheckFunc = checkFunc; - mBinderContextUserData = userData; + AutoMutex _l(mLock); + mBinderContextCheckFunc = checkFunc; + mBinderContextUserData = userData; - flat_binder_object obj { - .flags = FLAT_BINDER_FLAG_TXN_SECURITY_CTX, - }; + flat_binder_object obj { + .flags = FLAT_BINDER_FLAG_TXN_SECURITY_CTX, + }; - status_t result = ioctl(mDriverFD, BINDER_SET_CONTEXT_MGR_EXT, &obj); + int result = ioctl(mDriverFD, BINDER_SET_CONTEXT_MGR_EXT, &obj); - // fallback to original method - if (result != 0) { - android_errorWriteLog(0x534e4554, "121035042"); + // fallback to original method + if (result != 0) { + android_errorWriteLog(0x534e4554, "121035042"); - int dummy = 0; - result = ioctl(mDriverFD, BINDER_SET_CONTEXT_MGR, &dummy); - } + int dummy = 0; + result = ioctl(mDriverFD, BINDER_SET_CONTEXT_MGR, &dummy); + } - if (result == 0) { - mManagesContexts = true; - } else if (result == -1) { - mBinderContextCheckFunc = nullptr; - mBinderContextUserData = nullptr; - ALOGE("Binder ioctl to become context manager failed: %s\n", strerror(errno)); - } + if (result == -1) { + mBinderContextCheckFunc = nullptr; + mBinderContextUserData = nullptr; + ALOGE("Binder ioctl to become context manager failed: %s\n", strerror(errno)); } - return mManagesContexts; + + return result == 0; } // Get references to userspace objects held by the kernel binder driver @@ -249,10 +181,6 @@ ssize_t ProcessState::getKernelReferences(size_t buf_count, uintptr_t* buf) return count; } -size_t ProcessState::getMmapSize() { - return mMmapSize; -} - void ProcessState::setCallRestriction(CallRestriction restriction) { LOG_ALWAYS_FATAL_IF(IPCThreadState::selfOrNull(), "Call restrictions must be set before the threadpool is started."); @@ -437,7 +365,7 @@ static int open_driver(const char *driver) return fd; } -ProcessState::ProcessState(const char *driver, size_t mmap_size) +ProcessState::ProcessState(const char *driver) : mDriverName(String8(driver)) , mDriverFD(open_driver(driver)) , mVMStart(MAP_FAILED) @@ -446,17 +374,15 @@ ProcessState::ProcessState(const char *driver, size_t mmap_size) , mExecutingThreadsCount(0) , mMaxThreads(DEFAULT_MAX_BINDER_THREADS) , mStarvationStartTimeMs(0) - , mManagesContexts(false) , mBinderContextCheckFunc(nullptr) , mBinderContextUserData(nullptr) , mThreadPoolStarted(false) , mThreadPoolSeq(1) - , mMmapSize(mmap_size) , mCallRestriction(CallRestriction::NONE) { if (mDriverFD >= 0) { // mmap the binder, providing a chunk of virtual address space to receive transactions. - mVMStart = mmap(nullptr, mMmapSize, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0); + mVMStart = mmap(nullptr, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0); if (mVMStart == MAP_FAILED) { // *sigh* ALOGE("Using %s failed: unable to mmap transaction memory.\n", mDriverName.c_str()); @@ -473,7 +399,7 @@ ProcessState::~ProcessState() { if (mDriverFD >= 0) { if (mVMStart != MAP_FAILED) { - munmap(mVMStart, mMmapSize); + munmap(mVMStart, BINDER_VM_SIZE); } close(mDriverFD); } diff --git a/libs/binder/Static.cpp b/libs/binder/Static.cpp index 8625c6f278..a6fd8c49e9 100644 --- a/libs/binder/Static.cpp +++ b/libs/binder/Static.cpp @@ -17,7 +17,7 @@ // All static variables go here, to control initialization and // destruction order in the library. -#include <private/binder/Static.h> +#include "Static.h" #include <binder/BufferedTextOutput.h> #include <binder/IPCThreadState.h> diff --git a/libs/binder/include/private/binder/Static.h b/libs/binder/Static.h index f8e0ee5f8d..f8e0ee5f8d 100644 --- a/libs/binder/include/private/binder/Static.h +++ b/libs/binder/Static.h diff --git a/libs/binder/TEST_MAPPING b/libs/binder/TEST_MAPPING new file mode 100644 index 0000000000..01e57d361e --- /dev/null +++ b/libs/binder/TEST_MAPPING @@ -0,0 +1,16 @@ +{ + "presubmit": [ + { + "name": "binderSafeInterfaceTest" + }, + { + "name": "binderDriverInterfaceTest" + }, + { + "name": "binderTextOutputTest" + }, + { + "name": "binderLibTest" + } + ] +} diff --git a/libs/binder/Value.cpp b/libs/binder/Value.cpp deleted file mode 100644 index 19c57ba128..0000000000 --- a/libs/binder/Value.cpp +++ /dev/null @@ -1,420 +0,0 @@ -/* - * Copyright (C) 2015 The Android Open Source Project - * - * 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. - */ - -#define LOG_TAG "Value" - -#include <binder/Value.h> - -#include <limits> - -#include <binder/IBinder.h> -#include <binder/Parcel.h> -#include <binder/Map.h> -#include <private/binder/ParcelValTypes.h> -#include <log/log.h> -#include <utils/Errors.h> - -using android::BAD_TYPE; -using android::BAD_VALUE; -using android::NO_ERROR; -using android::UNEXPECTED_NULL; -using android::Parcel; -using android::sp; -using android::status_t; -using std::map; -using std::set; -using std::vector; -using android::binder::Value; -using android::IBinder; -using android::os::PersistableBundle; -using namespace android::binder; - -// ==================================================================== - -#define RETURN_IF_FAILED(calledOnce) \ - do { \ - status_t returnStatus = calledOnce; \ - if (returnStatus) { \ - ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \ - return returnStatus; \ - } \ - } while(false) - -// ==================================================================== - -/* These `internal_type_ptr()` functions allow this - * class to work without C++ RTTI support. This technique - * only works properly when called directly from this file, - * but that is OK because that is the only place we will - * be calling them from. */ -template<class T> const void* internal_type_ptr() -{ - static const T *marker; - return (void*)▮ -} - -/* Allows the type to be specified by the argument - * instead of inside angle brackets. */ -template<class T> const void* internal_type_ptr(const T&) -{ - return internal_type_ptr<T>(); -} - -// ==================================================================== - -namespace android { - -namespace binder { - -class Value::ContentBase { -public: - virtual ~ContentBase() = default; - virtual const void* type_ptr() const = 0; - virtual ContentBase * clone() const = 0; - virtual bool operator==(const ContentBase& rhs) const = 0; - -#ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO - virtual const std::type_info &type() const = 0; -#endif - - template<typename T> bool get(T* out) const; -}; - -/* This is the actual class that holds the value. */ -template<typename T> class Value::Content : public Value::ContentBase { -public: - Content() = default; - explicit Content(const T & value) : mValue(value) { } - - virtual ~Content() = default; - -#ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO - virtual const std::type_info &type() const override - { - return typeid(T); - } -#endif - - virtual const void* type_ptr() const override - { - return internal_type_ptr<T>(); - } - - virtual ContentBase * clone() const override - { - return new Content(mValue); - }; - - virtual bool operator==(const ContentBase& rhs) const override - { - if (type_ptr() != rhs.type_ptr()) { - return false; - } - return mValue == static_cast<const Content<T>* >(&rhs)->mValue; - } - - T mValue; -}; - -template<typename T> bool Value::ContentBase::get(T* out) const -{ - if (internal_type_ptr(*out) != type_ptr()) - { - return false; - } - - *out = static_cast<const Content<T>*>(this)->mValue; - - return true; -} - -// ==================================================================== - -Value::Value() : mContent(nullptr) -{ -} - -Value::Value(const Value& value) - : mContent(value.mContent ? value.mContent->clone() : nullptr) -{ -} - -Value::~Value() -{ - delete mContent; -} - -bool Value::operator==(const Value& rhs) const -{ - const Value& lhs(*this); - - if (lhs.empty() && rhs.empty()) { - return true; - } - - if ( (lhs.mContent == nullptr) - || (rhs.mContent == nullptr) - ) { - return false; - } - - return *lhs.mContent == *rhs.mContent; -} - -Value& Value::swap(Value &rhs) -{ - std::swap(mContent, rhs.mContent); - return *this; -} - -Value& Value::operator=(const Value& rhs) -{ - if (this != &rhs) { - delete mContent; - mContent = rhs.mContent - ? rhs.mContent->clone() - : nullptr; - } - return *this; -} - -bool Value::empty() const -{ - return mContent == nullptr; -} - -void Value::clear() -{ - delete mContent; - mContent = nullptr; -} - -int32_t Value::parcelType() const -{ - const void* t_info(mContent ? mContent->type_ptr() : nullptr); - - if (t_info == internal_type_ptr<bool>()) return VAL_BOOLEAN; - if (t_info == internal_type_ptr<uint8_t>()) return VAL_BYTE; - if (t_info == internal_type_ptr<int32_t>()) return VAL_INTEGER; - if (t_info == internal_type_ptr<int64_t>()) return VAL_LONG; - if (t_info == internal_type_ptr<double>()) return VAL_DOUBLE; - if (t_info == internal_type_ptr<String16>()) return VAL_STRING; - - if (t_info == internal_type_ptr<vector<bool>>()) return VAL_BOOLEANARRAY; - if (t_info == internal_type_ptr<vector<uint8_t>>()) return VAL_BYTEARRAY; - if (t_info == internal_type_ptr<vector<int32_t>>()) return VAL_INTARRAY; - if (t_info == internal_type_ptr<vector<int64_t>>()) return VAL_LONGARRAY; - if (t_info == internal_type_ptr<vector<double>>()) return VAL_DOUBLEARRAY; - if (t_info == internal_type_ptr<vector<String16>>()) return VAL_STRINGARRAY; - - if (t_info == internal_type_ptr<Map>()) return VAL_MAP; - if (t_info == internal_type_ptr<PersistableBundle>()) return VAL_PERSISTABLEBUNDLE; - - return VAL_NULL; -} - -#ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO -const std::type_info& Value::type() const -{ - return mContent != nullptr - ? mContent->type() - : typeid(void); -} -#endif // ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO - -#define DEF_TYPE_ACCESSORS(T, TYPENAME) \ - bool Value::is ## TYPENAME() const \ - { \ - return mContent \ - ? internal_type_ptr<T>() == mContent->type_ptr() \ - : false; \ - } \ - bool Value::get ## TYPENAME(T* out) const \ - { \ - return mContent \ - ? mContent->get(out) \ - : false; \ - } \ - void Value::put ## TYPENAME(const T& in) \ - { \ - *this = in; \ - } \ - Value& Value::operator=(const T& rhs) \ - { \ - delete mContent; \ - mContent = new Content< T >(rhs); \ - return *this; \ - } \ - Value::Value(const T& value) \ - : mContent(new Content< T >(value)) \ - { } - -DEF_TYPE_ACCESSORS(bool, Boolean) -DEF_TYPE_ACCESSORS(int8_t, Byte) -DEF_TYPE_ACCESSORS(int32_t, Int) -DEF_TYPE_ACCESSORS(int64_t, Long) -DEF_TYPE_ACCESSORS(double, Double) -DEF_TYPE_ACCESSORS(String16, String) - -DEF_TYPE_ACCESSORS(std::vector<bool>, BooleanVector) -DEF_TYPE_ACCESSORS(std::vector<uint8_t>, ByteVector) -DEF_TYPE_ACCESSORS(std::vector<int32_t>, IntVector) -DEF_TYPE_ACCESSORS(std::vector<int64_t>, LongVector) -DEF_TYPE_ACCESSORS(std::vector<double>, DoubleVector) -DEF_TYPE_ACCESSORS(std::vector<String16>, StringVector) - -DEF_TYPE_ACCESSORS(::android::binder::Map, Map) -DEF_TYPE_ACCESSORS(PersistableBundle, PersistableBundle) - -bool Value::getString(String8* out) const -{ - String16 val; - bool ret = getString(&val); - if (ret) { - *out = String8(val); - } - return ret; -} - -bool Value::getString(::std::string* out) const -{ - String8 val; - bool ret = getString(&val); - if (ret) { - *out = val.string(); - } - return ret; -} - -status_t Value::writeToParcel(Parcel* parcel) const -{ - // This implementation needs to be kept in sync with the writeValue - // implementation in frameworks/base/core/java/android/os/Parcel.java - -#define BEGIN_HANDLE_WRITE() \ - do { \ - const void* t_info(mContent?mContent->type_ptr():nullptr); \ - if (false) { } -#define HANDLE_WRITE_TYPE(T, TYPEVAL, TYPEMETHOD) \ - else if (t_info == internal_type_ptr<T>()) { \ - RETURN_IF_FAILED(parcel->writeInt32(TYPEVAL)); \ - RETURN_IF_FAILED(parcel->TYPEMETHOD(static_cast<const Content<T>*>(mContent)->mValue)); \ - } -#define HANDLE_WRITE_PARCELABLE(T, TYPEVAL) \ - else if (t_info == internal_type_ptr<T>()) { \ - RETURN_IF_FAILED(parcel->writeInt32(TYPEVAL)); \ - RETURN_IF_FAILED(static_cast<const Content<T>*>(mContent)->mValue.writeToParcel(parcel)); \ - } -#define END_HANDLE_WRITE() \ - else { \ - ALOGE("writeToParcel: Type not supported"); \ - return BAD_TYPE; \ - } \ - } while (false); - - BEGIN_HANDLE_WRITE() - - HANDLE_WRITE_TYPE(bool, VAL_BOOLEAN, writeBool) - HANDLE_WRITE_TYPE(int8_t, VAL_BYTE, writeByte) - HANDLE_WRITE_TYPE(int8_t, VAL_BYTE, writeByte) - HANDLE_WRITE_TYPE(int32_t, VAL_INTEGER, writeInt32) - HANDLE_WRITE_TYPE(int64_t, VAL_LONG, writeInt64) - HANDLE_WRITE_TYPE(double, VAL_DOUBLE, writeDouble) - HANDLE_WRITE_TYPE(String16, VAL_STRING, writeString16) - - HANDLE_WRITE_TYPE(vector<bool>, VAL_BOOLEANARRAY, writeBoolVector) - HANDLE_WRITE_TYPE(vector<uint8_t>, VAL_BYTEARRAY, writeByteVector) - HANDLE_WRITE_TYPE(vector<int8_t>, VAL_BYTEARRAY, writeByteVector) - HANDLE_WRITE_TYPE(vector<int32_t>, VAL_INTARRAY, writeInt32Vector) - HANDLE_WRITE_TYPE(vector<int64_t>, VAL_LONGARRAY, writeInt64Vector) - HANDLE_WRITE_TYPE(vector<double>, VAL_DOUBLEARRAY, writeDoubleVector) - HANDLE_WRITE_TYPE(vector<String16>, VAL_STRINGARRAY, writeString16Vector) - - HANDLE_WRITE_PARCELABLE(PersistableBundle, VAL_PERSISTABLEBUNDLE) - - END_HANDLE_WRITE() - - return NO_ERROR; - -#undef BEGIN_HANDLE_WRITE -#undef HANDLE_WRITE_TYPE -#undef HANDLE_WRITE_PARCELABLE -#undef END_HANDLE_WRITE -} - -status_t Value::readFromParcel(const Parcel* parcel) -{ - // This implementation needs to be kept in sync with the readValue - // implementation in frameworks/base/core/java/android/os/Parcel.javai - -#define BEGIN_HANDLE_READ() \ - switch(value_type) { \ - default: \ - ALOGE("readFromParcel: Parcel type %d is not supported", value_type); \ - return BAD_TYPE; -#define HANDLE_READ_TYPE(T, TYPEVAL, TYPEMETHOD) \ - case TYPEVAL: \ - mContent = new Content<T>(); \ - RETURN_IF_FAILED(parcel->TYPEMETHOD(&static_cast<Content<T>*>(mContent)->mValue)); \ - break; -#define HANDLE_READ_PARCELABLE(T, TYPEVAL) \ - case TYPEVAL: \ - mContent = new Content<T>(); \ - RETURN_IF_FAILED(static_cast<Content<T>*>(mContent)->mValue.readFromParcel(parcel)); \ - break; -#define END_HANDLE_READ() \ - } - - int32_t value_type = VAL_NULL; - - delete mContent; - mContent = nullptr; - - RETURN_IF_FAILED(parcel->readInt32(&value_type)); - - BEGIN_HANDLE_READ() - - HANDLE_READ_TYPE(bool, VAL_BOOLEAN, readBool) - HANDLE_READ_TYPE(int8_t, VAL_BYTE, readByte) - HANDLE_READ_TYPE(int32_t, VAL_INTEGER, readInt32) - HANDLE_READ_TYPE(int64_t, VAL_LONG, readInt64) - HANDLE_READ_TYPE(double, VAL_DOUBLE, readDouble) - HANDLE_READ_TYPE(String16, VAL_STRING, readString16) - - HANDLE_READ_TYPE(vector<bool>, VAL_BOOLEANARRAY, readBoolVector) - HANDLE_READ_TYPE(vector<uint8_t>, VAL_BYTEARRAY, readByteVector) - HANDLE_READ_TYPE(vector<int32_t>, VAL_INTARRAY, readInt32Vector) - HANDLE_READ_TYPE(vector<int64_t>, VAL_LONGARRAY, readInt64Vector) - HANDLE_READ_TYPE(vector<double>, VAL_DOUBLEARRAY, readDoubleVector) - HANDLE_READ_TYPE(vector<String16>, VAL_STRINGARRAY, readString16Vector) - - HANDLE_READ_PARCELABLE(PersistableBundle, VAL_PERSISTABLEBUNDLE) - - END_HANDLE_READ() - - return NO_ERROR; - -#undef BEGIN_HANDLE_READ -#undef HANDLE_READ_TYPE -#undef HANDLE_READ_PARCELABLE -#undef END_HANDLE_READ -} - -} // namespace binder - -} // namespace android - -/* vim: set ts=4 sw=4 tw=0 et :*/ diff --git a/libs/binder/include/binder/BpBinder.h b/libs/binder/include/binder/BpBinder.h index 78f2e1d831..b3a1d0b7e9 100644 --- a/libs/binder/include/binder/BpBinder.h +++ b/libs/binder/include/binder/BpBinder.h @@ -34,7 +34,7 @@ class BpBinder : public IBinder public: static BpBinder* create(int32_t handle); - inline int32_t handle() const { return mHandle; } + int32_t handle() const; virtual const String16& getInterfaceDescriptor() const; virtual bool isBinderAlive() const; diff --git a/libs/binder/include/binder/Parcel.h b/libs/binder/include/binder/Parcel.h index 0046e3ae85..b65d4565fc 100644 --- a/libs/binder/include/binder/Parcel.h +++ b/libs/binder/include/binder/Parcel.h @@ -17,6 +17,7 @@ #ifndef ANDROID_PARCEL_H #define ANDROID_PARCEL_H +#include <map> // for legacy reasons #include <string> #include <vector> @@ -32,7 +33,6 @@ #include <binder/IInterface.h> #include <binder/Parcelable.h> -#include <binder/Map.h> // --------------------------------------------------------------------------- namespace android { @@ -97,10 +97,6 @@ public: void freeData(); -private: - const binder_size_t* objects() const; - -public: size_t objectsCount() const; status_t errorCheck() const; @@ -172,8 +168,6 @@ public: status_t writeParcelable(const Parcelable& parcelable); - status_t writeValue(const binder::Value& value); - template<typename T> status_t write(const Flattenable<T>& val); @@ -185,9 +179,6 @@ public: template<typename T> status_t writeVectorSize(const std::unique_ptr<std::vector<T>>& val); - status_t writeMap(const binder::Map& map); - status_t writeNullableMap(const std::unique_ptr<binder::Map>& map); - // Place a native_handle into the parcel (the native_handle's file- // descriptors are dup'ed, so it is safe to delete the native_handle // when this function returns). @@ -244,8 +235,6 @@ public: // Currently the native implementation doesn't do any of the StrictMode // stack gathering and serialization that the Java implementation does. status_t writeNoException(); - - void remove(size_t start, size_t amt); status_t read(void* outData, size_t len) const; const void* readInplace(size_t len) const; @@ -297,8 +286,6 @@ public: template<typename T> status_t readParcelable(std::unique_ptr<T>* parcelable) const; - status_t readValue(binder::Value* value) const; - template<typename T> status_t readStrongBinder(sp<T>* val) const; @@ -344,9 +331,6 @@ public: template<typename T> status_t resizeOutVector(std::unique_ptr<std::vector<T>>* val) const; - status_t readMap(binder::Map* map)const; - status_t readNullableMap(std::unique_ptr<binder::Map>* map) const; - // Like Parcel.java's readExceptionCode(). Reads the first int32 // off of a Parcel's header, returning 0 or the negative error // code on exceptions, but also deals with skipping over rich diff --git a/libs/binder/include/binder/ProcessState.h b/libs/binder/include/binder/ProcessState.h index 1622ba2712..3af9eed9c6 100644 --- a/libs/binder/include/binder/ProcessState.h +++ b/libs/binder/include/binder/ProcessState.h @@ -36,8 +36,6 @@ class ProcessState : public virtual RefBase public: static sp<ProcessState> self(); static sp<ProcessState> selfOrNull(); - // Note: don't call self() or selfOrNull() before initWithMmapSize() - static sp<ProcessState> initWithMmapSize(size_t mmapSize); // size in bytes /* initWithDriver() can be used to configure libbinder to use * a different binder driver dev node. It must be called *before* @@ -47,21 +45,14 @@ public: */ static sp<ProcessState> initWithDriver(const char *driver); - void setContextObject(const sp<IBinder>& object); sp<IBinder> getContextObject(const sp<IBinder>& caller); - - void setContextObject(const sp<IBinder>& object, - const String16& name); - sp<IBinder> getContextObject(const String16& name, - const sp<IBinder>& caller); void startThreadPool(); typedef bool (*context_check_func)(const String16& name, const sp<IBinder>& caller, void* userData); - - bool isContextManager(void) const; + bool becomeContextManager( context_check_func checkFunc, void* userData); @@ -78,7 +69,6 @@ public: String8 getDriverName(); ssize_t getKernelReferences(size_t count, uintptr_t* buf); - size_t getMmapSize(); enum class CallRestriction { // all calls okay @@ -95,7 +85,7 @@ public: private: friend class IPCThreadState; - explicit ProcessState(const char* driver, size_t mmap_size); + explicit ProcessState(const char* driver); ~ProcessState(); ProcessState(const ProcessState& o); @@ -124,23 +114,15 @@ private: int64_t mStarvationStartTimeMs; mutable Mutex mLock; // protects everything below. - // TODO: mManagesContexts is often accessed without the lock. - // Explain why that's safe. Vector<handle_entry>mHandleToObject; - bool mManagesContexts; context_check_func mBinderContextCheckFunc; void* mBinderContextUserData; - KeyedVector<String16, sp<IBinder> > - mContexts; - - String8 mRootDir; bool mThreadPoolStarted; volatile int32_t mThreadPoolSeq; - const size_t mMmapSize; CallRestriction mCallRestriction; }; diff --git a/libs/binder/include/binder/Value.h b/libs/binder/include/binder/Value.h deleted file mode 100644 index 735f40eb1f..0000000000 --- a/libs/binder/include/binder/Value.h +++ /dev/null @@ -1,186 +0,0 @@ -/* - * Copyright (C) 2015 The Android Open Source Project - * - * 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. - */ - -#ifndef ANDROID_VALUE_H -#define ANDROID_VALUE_H - -#include <stdint.h> -#include <map> -#include <set> -#include <vector> -#include <string> - -#include <binder/Parcelable.h> -#include <binder/PersistableBundle.h> -#include <binder/Map.h> -#include <utils/String8.h> -#include <utils/String16.h> -#include <utils/StrongPointer.h> - -namespace android { - -class Parcel; - -namespace binder { - -/** - * A limited C++ generic type. The purpose of this class is to allow C++ - * programs to make use of (or implement) Binder interfaces which make use - * the Java "Object" generic type (either via the use of the Map type or - * some other mechanism). - * - * This class only supports a limited set of types, but additional types - * may be easily added to this class in the future as needed---without - * breaking binary compatability. - * - * This class was written in such a way as to help avoid type errors by - * giving each type their own explicity-named accessor methods (rather than - * overloaded methods). - * - * When reading or writing this class to a Parcel, use the `writeValue()` - * and `readValue()` methods. - */ -class Value { -public: - Value(); - virtual ~Value(); - - Value& swap(Value &); - - bool empty() const; - - void clear(); - -#ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO - const std::type_info& type() const; -#endif - - int32_t parcelType() const; - - bool operator==(const Value& rhs) const; - bool operator!=(const Value& rhs) const { return !this->operator==(rhs); } - - Value(const Value& value); - Value(const bool& value); // NOLINT(google-explicit-constructor) - Value(const int8_t& value); // NOLINT(google-explicit-constructor) - Value(const int32_t& value); // NOLINT(google-explicit-constructor) - Value(const int64_t& value); // NOLINT(google-explicit-constructor) - Value(const double& value); // NOLINT(google-explicit-constructor) - Value(const String16& value); // NOLINT(google-explicit-constructor) - Value(const std::vector<bool>& value); // NOLINT(google-explicit-constructor) - Value(const std::vector<uint8_t>& value); // NOLINT(google-explicit-constructor) - Value(const std::vector<int32_t>& value); // NOLINT(google-explicit-constructor) - Value(const std::vector<int64_t>& value); // NOLINT(google-explicit-constructor) - Value(const std::vector<double>& value); // NOLINT(google-explicit-constructor) - Value(const std::vector<String16>& value); // NOLINT(google-explicit-constructor) - Value(const os::PersistableBundle& value); // NOLINT(google-explicit-constructor) - Value(const binder::Map& value); // NOLINT(google-explicit-constructor) - - Value& operator=(const Value& rhs); - Value& operator=(const int8_t& rhs); - Value& operator=(const bool& rhs); - Value& operator=(const int32_t& rhs); - Value& operator=(const int64_t& rhs); - Value& operator=(const double& rhs); - Value& operator=(const String16& rhs); - Value& operator=(const std::vector<bool>& rhs); - Value& operator=(const std::vector<uint8_t>& rhs); - Value& operator=(const std::vector<int32_t>& rhs); - Value& operator=(const std::vector<int64_t>& rhs); - Value& operator=(const std::vector<double>& rhs); - Value& operator=(const std::vector<String16>& rhs); - Value& operator=(const os::PersistableBundle& rhs); - Value& operator=(const binder::Map& rhs); - - void putBoolean(const bool& value); - void putByte(const int8_t& value); - void putInt(const int32_t& value); - void putLong(const int64_t& value); - void putDouble(const double& value); - void putString(const String16& value); - void putBooleanVector(const std::vector<bool>& value); - void putByteVector(const std::vector<uint8_t>& value); - void putIntVector(const std::vector<int32_t>& value); - void putLongVector(const std::vector<int64_t>& value); - void putDoubleVector(const std::vector<double>& value); - void putStringVector(const std::vector<String16>& value); - void putPersistableBundle(const os::PersistableBundle& value); - void putMap(const binder::Map& value); - - bool getBoolean(bool* out) const; - bool getByte(int8_t* out) const; - bool getInt(int32_t* out) const; - bool getLong(int64_t* out) const; - bool getDouble(double* out) const; - bool getString(String16* out) const; - bool getBooleanVector(std::vector<bool>* out) const; - bool getByteVector(std::vector<uint8_t>* out) const; - bool getIntVector(std::vector<int32_t>* out) const; - bool getLongVector(std::vector<int64_t>* out) const; - bool getDoubleVector(std::vector<double>* out) const; - bool getStringVector(std::vector<String16>* out) const; - bool getPersistableBundle(os::PersistableBundle* out) const; - bool getMap(binder::Map* out) const; - - bool isBoolean() const; - bool isByte() const; - bool isInt() const; - bool isLong() const; - bool isDouble() const; - bool isString() const; - bool isBooleanVector() const; - bool isByteVector() const; - bool isIntVector() const; - bool isLongVector() const; - bool isDoubleVector() const; - bool isStringVector() const; - bool isPersistableBundle() const; - bool isMap() const; - - // String Convenience Adapters - // --------------------------- - - explicit Value(const String8& value): Value(String16(value)) { } - explicit Value(const ::std::string& value): Value(String8(value.c_str())) { } - void putString(const String8& value) { return putString(String16(value)); } - void putString(const ::std::string& value) { return putString(String8(value.c_str())); } - Value& operator=(const String8& rhs) { return *this = String16(rhs); } - Value& operator=(const ::std::string& rhs) { return *this = String8(rhs.c_str()); } - bool getString(String8* out) const; - bool getString(::std::string* out) const; - -private: - - // This allows ::android::Parcel to call the two methods below. - friend class ::android::Parcel; - - // This is called by ::android::Parcel::writeValue() - status_t writeToParcel(Parcel* parcel) const; - - // This is called by ::android::Parcel::readValue() - status_t readFromParcel(const Parcel* parcel); - - template<typename T> class Content; - class ContentBase; - - ContentBase* mContent; -}; - -} // namespace binder - -} // namespace android - -#endif // ANDROID_VALUE_H diff --git a/libs/binder/ndk/Android.bp b/libs/binder/ndk/Android.bp index 21bef2e930..6da30866d8 100644 --- a/libs/binder/ndk/Android.bp +++ b/libs/binder/ndk/Android.bp @@ -16,7 +16,6 @@ cc_library { name: "libbinder_ndk", - vendor_available: true, export_include_dirs: [ "include_ndk", @@ -74,3 +73,12 @@ ndk_library { symbol_file: "libbinder_ndk.map.txt", first_version: "29", } + +llndk_library { + name: "libbinder_ndk", + symbol_file: "libbinder_ndk.map.txt", + export_include_dirs: [ + "include_ndk", + "include_apex", + ], +} diff --git a/libs/binder/ndk/libbinder_ndk.map.txt b/libs/binder/ndk/libbinder_ndk.map.txt index 7e6581736f..4f685d1241 100644 --- a/libs/binder/ndk/libbinder_ndk.map.txt +++ b/libs/binder/ndk/libbinder_ndk.map.txt @@ -89,12 +89,12 @@ LIBBINDER_NDK { # introduced=29 AStatus_getStatus; AStatus_isOk; AStatus_newOk; - ABinderProcess_joinThreadPool; # apex - ABinderProcess_setThreadPoolMaxThreadCount; # apex - ABinderProcess_startThreadPool; # apex - AServiceManager_addService; # apex - AServiceManager_checkService; # apex - AServiceManager_getService; # apex + ABinderProcess_joinThreadPool; # apex vndk + ABinderProcess_setThreadPoolMaxThreadCount; # apex vndk + ABinderProcess_startThreadPool; # apex vndk + AServiceManager_addService; # apex vndk + AServiceManager_checkService; # apex vndk + AServiceManager_getService; # apex vndk local: *; }; diff --git a/libs/binder/tests/Android.bp b/libs/binder/tests/Android.bp index 3e005c958e..44a691d594 100644 --- a/libs/binder/tests/Android.bp +++ b/libs/binder/tests/Android.bp @@ -19,8 +19,6 @@ cc_defaults { cflags: [ "-Wall", "-Werror", - "-Wno-unused-private-field", - "-Wno-unused-variable", ], } @@ -42,16 +40,7 @@ cc_test { }, srcs: ["binderDriverInterfaceTest.cpp"], -} - -cc_test { - name: "binderValueTypeTest", - defaults: ["binder_test_defaults"], - srcs: ["binderValueTypeTest.cpp"], - shared_libs: [ - "libbinder", - "libutils", - ], + test_suites: ["device-tests"], } cc_test { @@ -80,6 +69,7 @@ cc_test { "libbinder", "libutils", ], + test_suites: ["device-tests"], } cc_test { @@ -108,6 +98,7 @@ cc_test { "libutils", "libbase", ], + test_suites: ["device-tests"], } cc_test { @@ -144,4 +135,5 @@ cc_test { "liblog", "libutils", ], + test_suites: ["device-tests"], } diff --git a/libs/binder/tests/binderDriverInterfaceTest.cpp b/libs/binder/tests/binderDriverInterfaceTest.cpp index 6508bb1283..f3ed6a613c 100644 --- a/libs/binder/tests/binderDriverInterfaceTest.cpp +++ b/libs/binder/tests/binderDriverInterfaceTest.cpp @@ -230,7 +230,6 @@ TEST_F(BinderDriverInterfaceTest, IncRefsAcquireReleaseDecRefs) { } TEST_F(BinderDriverInterfaceTest, Transaction) { - binder_uintptr_t cookie = 1234; struct { uint32_t cmd1; struct binder_transaction_data arg1; @@ -286,13 +285,7 @@ TEST_F(BinderDriverInterfaceTest, Transaction) { EXPECT_EQ(0u, br.arg2.cookie); EXPECT_EQ(0u, br.arg2.code); EXPECT_EQ(0u, br.arg2.flags); - - // ping returns a 4 byte header in libbinder, but the original - // C implementation of servicemanager returns a 0 byte header - if (br.arg2.data_size != 0 && br.arg2.data_size != 4) { - ADD_FAILURE() << br.arg2.data_size << " is expected to be 0 or 4"; - } - + EXPECT_EQ(0u, br.arg2.data_size); EXPECT_EQ(0u, br.arg2.offsets_size); SCOPED_TRACE("3rd WriteRead"); diff --git a/libs/binder/tests/binderLibTest.cpp b/libs/binder/tests/binderLibTest.cpp index 78f11594b9..e51bcebba2 100644 --- a/libs/binder/tests/binderLibTest.cpp +++ b/libs/binder/tests/binderLibTest.cpp @@ -553,50 +553,6 @@ TEST_F(BinderLibTest, AddServer) ASSERT_TRUE(server != nullptr); } -TEST_F(BinderLibTest, DeathNotificationNoRefs) -{ - status_t ret; - - sp<TestDeathRecipient> testDeathRecipient = new TestDeathRecipient(); - - { - sp<IBinder> binder = addServer(); - ASSERT_TRUE(binder != nullptr); - ret = binder->linkToDeath(testDeathRecipient); - EXPECT_EQ(NO_ERROR, ret); - } - IPCThreadState::self()->flushCommands(); - ret = testDeathRecipient->waitEvent(5); - EXPECT_EQ(NO_ERROR, ret); -#if 0 /* Is there an unlink api that does not require a strong reference? */ - ret = binder->unlinkToDeath(testDeathRecipient); - EXPECT_EQ(NO_ERROR, ret); -#endif -} - -TEST_F(BinderLibTest, DeathNotificationWeakRef) -{ - status_t ret; - wp<IBinder> wbinder; - - sp<TestDeathRecipient> testDeathRecipient = new TestDeathRecipient(); - - { - sp<IBinder> binder = addServer(); - ASSERT_TRUE(binder != nullptr); - ret = binder->linkToDeath(testDeathRecipient); - EXPECT_EQ(NO_ERROR, ret); - wbinder = binder; - } - IPCThreadState::self()->flushCommands(); - ret = testDeathRecipient->waitEvent(5); - EXPECT_EQ(NO_ERROR, ret); -#if 0 /* Is there an unlink api that does not require a strong reference? */ - ret = binder->unlinkToDeath(testDeathRecipient); - EXPECT_EQ(NO_ERROR, ret); -#endif -} - TEST_F(BinderLibTest, DeathNotificationStrongRef) { status_t ret; @@ -1015,9 +971,6 @@ TEST_F(BinderLibTest, WorkSourceRestored) TEST_F(BinderLibTest, PropagateFlagSet) { - status_t ret; - Parcel data, reply; - IPCThreadState::self()->clearPropagateWorkSource(); IPCThreadState::self()->setCallingWorkSourceUid(100); EXPECT_EQ(true, IPCThreadState::self()->shouldPropagateWorkSource()); @@ -1025,9 +978,6 @@ TEST_F(BinderLibTest, PropagateFlagSet) TEST_F(BinderLibTest, PropagateFlagCleared) { - status_t ret; - Parcel data, reply; - IPCThreadState::self()->setCallingWorkSourceUid(100); IPCThreadState::self()->clearPropagateWorkSource(); EXPECT_EQ(false, IPCThreadState::self()->shouldPropagateWorkSource()); @@ -1035,9 +985,6 @@ TEST_F(BinderLibTest, PropagateFlagCleared) TEST_F(BinderLibTest, PropagateFlagRestored) { - status_t ret; - Parcel data, reply; - int token = IPCThreadState::self()->setCallingWorkSourceUid(100); IPCThreadState::self()->restoreCallingWorkSource(token); @@ -1136,7 +1083,6 @@ class BinderLibTestService : public BBinder case BINDER_LIB_TEST_ADD_POLL_SERVER: case BINDER_LIB_TEST_ADD_SERVER: { int ret; - uint8_t buf[1] = { 0 }; int serverid; if (m_id != 0) { @@ -1399,7 +1345,6 @@ class BinderLibTestService : public BBinder bool m_serverStartRequested; sp<IBinder> m_serverStarted; sp<IBinder> m_strongRef; - bool m_callbackPending; sp<IBinder> m_callback; }; @@ -1461,7 +1406,7 @@ int run_server(int index, int readypipefd, bool usePoll) * We simulate a single-threaded process using the binder poll * interface; besides handling binder commands, it can also * issue outgoing transactions, by storing a callback in - * m_callback and setting m_callbackPending. + * m_callback. * * processPendingCall() will then issue that transaction. */ @@ -1488,8 +1433,6 @@ int run_server(int index, int readypipefd, bool usePoll) } int main(int argc, char **argv) { - int ret; - if (argc == 4 && !strcmp(argv[1], "--servername")) { binderservername = argv[2]; } else { diff --git a/libs/binder/tests/binderSafeInterfaceTest.cpp b/libs/binder/tests/binderSafeInterfaceTest.cpp index 3b1db27749..09f58cc833 100644 --- a/libs/binder/tests/binderSafeInterfaceTest.cpp +++ b/libs/binder/tests/binderSafeInterfaceTest.cpp @@ -75,7 +75,7 @@ public: private: int32_t mValue = 0; - uint8_t mPadding[4] = {}; // Avoids a warning from -Wpadded + __attribute__((unused)) uint8_t mPadding[4] = {}; // Avoids a warning from -Wpadded }; struct TestFlattenable : Flattenable<TestFlattenable> { @@ -743,6 +743,7 @@ TEST_F(SafeInterfaceTest, TestIncremementParcelableVector) { const std::vector<TestParcelable> a{TestParcelable{1}, TestParcelable{2}}; std::vector<TestParcelable> aPlusOne; status_t result = mSafeInterfaceTest->increment(a, &aPlusOne); + ASSERT_EQ(NO_ERROR, result); ASSERT_EQ(a.size(), aPlusOne.size()); for (size_t i = 0; i < a.size(); ++i) { ASSERT_EQ(a[i].getValue() + 1, aPlusOne[i].getValue()); diff --git a/libs/binder/tests/binderValueTypeTest.cpp b/libs/binder/tests/binderValueTypeTest.cpp deleted file mode 100644 index f8922b0784..0000000000 --- a/libs/binder/tests/binderValueTypeTest.cpp +++ /dev/null @@ -1,110 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * - * 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. - */ - -#include <fcntl.h> -#include <stdio.h> -#include <stdlib.h> -#include <limits> -#include <cstddef> -#include <vector> - -#include "android-base/file.h" -#include <gtest/gtest.h> - -#include <binder/Parcel.h> -#include <binder/Value.h> -#include <binder/Debug.h> - -using ::android::binder::Value; -using ::android::os::PersistableBundle; -using ::android::String16; -using ::std::vector; - -#define VALUE_TYPE_TEST(T, TYPENAME, VAL) \ - TEST(ValueType, Handles ## TYPENAME) { \ - T x = VAL; \ - T y = T(); \ - Value value = VAL; \ - ASSERT_FALSE(value.empty()); \ - ASSERT_TRUE(value.is ## TYPENAME ()); \ - ASSERT_TRUE(value.get ## TYPENAME (&y)); \ - ASSERT_EQ(x, y); \ - ASSERT_EQ(value, Value(y)); \ - value.put ## TYPENAME (x); \ - ASSERT_EQ(value, Value(y)); \ - value = Value(); \ - ASSERT_TRUE(value.empty()); \ - ASSERT_NE(value, Value(y)); \ - value = y; \ - ASSERT_EQ(value, Value(x)); \ - } - -#define VALUE_TYPE_VECTOR_TEST(T, TYPENAME, VAL) \ - TEST(ValueType, Handles ## TYPENAME ## Vector) { \ - vector<T> x; \ - vector<T> y; \ - x.push_back(VAL); \ - x.push_back(T()); \ - Value value(x); \ - ASSERT_FALSE(value.empty()); \ - ASSERT_TRUE(value.is ## TYPENAME ## Vector()); \ - ASSERT_TRUE(value.get ## TYPENAME ## Vector(&y)); \ - ASSERT_EQ(x, y); \ - ASSERT_EQ(value, Value(y)); \ - value.put ## TYPENAME ## Vector(x); \ - ASSERT_EQ(value, Value(y)); \ - value = Value(); \ - ASSERT_TRUE(value.empty()); \ - ASSERT_NE(value, Value(y)); \ - value = y; \ - ASSERT_EQ(value, Value(x)); \ - } - -VALUE_TYPE_TEST(bool, Boolean, true) -VALUE_TYPE_TEST(int32_t, Int, 31337) -VALUE_TYPE_TEST(int64_t, Long, 13370133701337L) -VALUE_TYPE_TEST(double, Double, 3.14159265358979323846) -VALUE_TYPE_TEST(String16, String, String16("Lovely")) - -VALUE_TYPE_VECTOR_TEST(bool, Boolean, true) -VALUE_TYPE_VECTOR_TEST(int32_t, Int, 31337) -VALUE_TYPE_VECTOR_TEST(int64_t, Long, 13370133701337L) -VALUE_TYPE_VECTOR_TEST(double, Double, 3.14159265358979323846) -VALUE_TYPE_VECTOR_TEST(String16, String, String16("Lovely")) - -VALUE_TYPE_TEST(PersistableBundle, PersistableBundle, PersistableBundle()) - -TEST(ValueType, HandlesClear) { - Value value; - ASSERT_TRUE(value.empty()); - value.putInt(31337); - ASSERT_FALSE(value.empty()); - value.clear(); - ASSERT_TRUE(value.empty()); -} - -TEST(ValueType, HandlesSwap) { - Value value_a, value_b; - int32_t int_x; - value_a.putInt(31337); - ASSERT_FALSE(value_a.empty()); - ASSERT_TRUE(value_b.empty()); - value_a.swap(value_b); - ASSERT_FALSE(value_b.empty()); - ASSERT_TRUE(value_a.empty()); - ASSERT_TRUE(value_b.getInt(&int_x)); - ASSERT_EQ(31337, int_x); -} diff --git a/libs/binder/tests/schd-dbg.cpp b/libs/binder/tests/schd-dbg.cpp index ec9534abac..ab4c56a6af 100644 --- a/libs/binder/tests/schd-dbg.cpp +++ b/libs/binder/tests/schd-dbg.cpp @@ -290,6 +290,7 @@ static void* thread_start(void* p) { sta = tickNow(); status_t ret = workers[target]->transact(BINDER_NOP, data, &reply); + ASSERT(ret == NO_ERROR); end = tickNow(); results_fifo->add_time(tickNano(sta, end)); diff --git a/libs/cputimeinstate/Android.bp b/libs/cputimeinstate/Android.bp index 28cb13827d..9080ce13db 100644 --- a/libs/cputimeinstate/Android.bp +++ b/libs/cputimeinstate/Android.bp @@ -19,7 +19,11 @@ cc_test { name: "libtimeinstate_test", srcs: ["testtimeinstate.cpp"], shared_libs: [ + "libbase", + "libbpf", + "libbpf_android", "libtimeinstate", + "libnetdutils", ], cflags: [ "-Werror", diff --git a/libs/cputimeinstate/cputimeinstate.cpp b/libs/cputimeinstate/cputimeinstate.cpp index 41cbde1c18..0e68e628b6 100644 --- a/libs/cputimeinstate/cputimeinstate.cpp +++ b/libs/cputimeinstate/cputimeinstate.cpp @@ -17,6 +17,7 @@ #define LOG_TAG "libtimeinstate" #include "cputimeinstate.h" +#include "timeinstate.h" #include <dirent.h> #include <errno.h> @@ -38,23 +39,12 @@ #include <libbpf.h> #include <log/log.h> -#define BPF_FS_PATH "/sys/fs/bpf/" - using android::base::StringPrintf; using android::base::unique_fd; namespace android { namespace bpf { -struct time_key_t { - uint32_t uid; - uint32_t freq; -}; - -struct val_t { - uint64_t ar[100]; -}; - static std::mutex gInitializedMutex; static bool gInitialized = false; static uint32_t gNPolicies = 0; diff --git a/libs/cputimeinstate/testtimeinstate.cpp b/libs/cputimeinstate/testtimeinstate.cpp index d4b87386e0..6347de166a 100644 --- a/libs/cputimeinstate/testtimeinstate.cpp +++ b/libs/cputimeinstate/testtimeinstate.cpp @@ -1,14 +1,24 @@ +#include "timeinstate.h" + +#include <sys/sysinfo.h> + #include <unordered_map> #include <vector> #include <gtest/gtest.h> +#include <android-base/unique_fd.h> +#include <bpf/BpfMap.h> #include <cputimeinstate.h> +#include <libbpf.h> namespace android { namespace bpf { +static constexpr uint64_t NSEC_PER_SEC = 1000000000; +static constexpr uint64_t NSEC_PER_YEAR = NSEC_PER_SEC * 60 * 60 * 24 * 365; + using std::vector; TEST(TimeInStateTest, SingleUid) { @@ -33,8 +43,95 @@ TEST(TimeInStateTest, AllUid) { } } +TEST(TimeInStateTest, SingleAndAllUidConsistent) { + auto map = getUidsCpuFreqTimes(); + ASSERT_TRUE(map.has_value()); + ASSERT_FALSE(map->empty()); + + for (const auto &kv : *map) { + uint32_t uid = kv.first; + auto times1 = kv.second; + auto times2 = getUidCpuFreqTimes(uid); + ASSERT_TRUE(times2.has_value()); + + ASSERT_EQ(times1.size(), times2->size()); + for (uint32_t i = 0; i < times1.size(); ++i) { + ASSERT_EQ(times1[i].size(), (*times2)[i].size()); + for (uint32_t j = 0; j < times1[i].size(); ++j) { + ASSERT_LE((*times2)[i][j] - times1[i][j], NSEC_PER_SEC); + } + } + } +} + +void TestCheckDelta(uint64_t before, uint64_t after) { + // Times should never decrease + ASSERT_LE(before, after); + // UID can't have run for more than ~1s on each CPU + ASSERT_LE(after - before, NSEC_PER_SEC * 2 * get_nprocs_conf()); +} + +TEST(TimeInStateTest, AllUidMonotonic) { + auto map1 = getUidsCpuFreqTimes(); + ASSERT_TRUE(map1.has_value()); + sleep(1); + auto map2 = getUidsCpuFreqTimes(); + ASSERT_TRUE(map2.has_value()); + + for (const auto &kv : *map1) { + uint32_t uid = kv.first; + auto times = kv.second; + ASSERT_NE(map2->find(uid), map2->end()); + for (uint32_t policy = 0; policy < times.size(); ++policy) { + for (uint32_t freqIdx = 0; freqIdx < times[policy].size(); ++freqIdx) { + auto before = times[policy][freqIdx]; + auto after = (*map2)[uid][policy][freqIdx]; + ASSERT_NO_FATAL_FAILURE(TestCheckDelta(before, after)); + } + } + } +} + +TEST(TimeInStateTest, AllUidSanityCheck) { + auto map = getUidsCpuFreqTimes(); + ASSERT_TRUE(map.has_value()); + + bool foundLargeValue = false; + for (const auto &kv : *map) { + for (const auto &timeVec : kv.second) { + for (const auto &time : timeVec) { + ASSERT_LE(time, NSEC_PER_YEAR); + if (time > UINT32_MAX) foundLargeValue = true; + } + } + } + // UINT32_MAX nanoseconds is less than 5 seconds, so if every part of our pipeline is using + // uint64_t as expected, we should have some times higher than that. + ASSERT_TRUE(foundLargeValue); +} + TEST(TimeInStateTest, RemoveUid) { - auto times = getUidCpuFreqTimes(0); + uint32_t uid = 0; + { + // Find an unused UID + auto times = getUidsCpuFreqTimes(); + ASSERT_TRUE(times.has_value()); + ASSERT_FALSE(times->empty()); + for (const auto &kv : *times) uid = std::max(uid, kv.first); + ++uid; + } + { + // Add a map entry for our fake UID by copying a real map entry + android::base::unique_fd fd{bpf_obj_get(BPF_FS_PATH "map_time_in_state_uid_times_map")}; + ASSERT_GE(fd, 0); + time_key_t k; + ASSERT_FALSE(getFirstMapKey(fd, &k)); + val_t val; + ASSERT_FALSE(findMapEntry(fd, &k, &val)); + k.uid = uid; + ASSERT_FALSE(writeToMapEntry(fd, &k, &val, BPF_NOEXIST)); + } + auto times = getUidCpuFreqTimes(uid); ASSERT_TRUE(times.has_value()); ASSERT_FALSE(times->empty()); @@ -44,15 +141,12 @@ TEST(TimeInStateTest, RemoveUid) { } ASSERT_GT(sum, (uint64_t)0); - ASSERT_TRUE(clearUidCpuFreqTimes(0)); + ASSERT_TRUE(clearUidCpuFreqTimes(uid)); - auto times2 = getUidCpuFreqTimes(0); - ASSERT_TRUE(times2.has_value()); - ASSERT_EQ(times2->size(), times->size()); - for (size_t i = 0; i < times->size(); ++i) { - ASSERT_EQ((*times2)[i].size(), (*times)[i].size()); - for (size_t j = 0; j < (*times)[i].size(); ++j) ASSERT_LE((*times2)[i][j], (*times)[i][j]); - } + auto allTimes = getUidsCpuFreqTimes(); + ASSERT_TRUE(allTimes.has_value()); + ASSERT_FALSE(allTimes->empty()); + ASSERT_EQ(allTimes->find(uid), allTimes->end()); } } // namespace bpf diff --git a/libs/binder/include/binder/Map.h b/libs/cputimeinstate/timeinstate.h index 96a4f8a2a5..cf66ae7077 100644 --- a/libs/binder/include/binder/Map.h +++ b/libs/cputimeinstate/timeinstate.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005 The Android Open Source Project + * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,26 +14,15 @@ * limitations under the License. */ -#ifndef ANDROID_MAP_H -#define ANDROID_MAP_H +#include <inttypes.h> -#include <map> -#include <string> +#define BPF_FS_PATH "/sys/fs/bpf/" -// --------------------------------------------------------------------------- -namespace android { -namespace binder { +struct time_key_t { + uint32_t uid; + uint32_t freq; +}; -class Value; - -/** - * Convenience typedef for ::std::map<::std::string,::android::binder::Value> - */ -typedef ::std::map<::std::string, Value> Map; - -} // namespace binder -} // namespace android - -// --------------------------------------------------------------------------- - -#endif // ANDROID_MAP_H +struct val_t { + uint64_t ar[100]; +}; diff --git a/libs/dumputils/Android.bp b/libs/dumputils/Android.bp index 3412e14f17..e23de8e389 100644 --- a/libs/dumputils/Android.bp +++ b/libs/dumputils/Android.bp @@ -17,7 +17,6 @@ cc_library { shared_libs: [ "libbase", - "libbinder", "libhidlbase", "libhidltransport", "liblog", diff --git a/libs/gui/Android.bp b/libs/gui/Android.bp index b2a7557588..beb13ad2cd 100644 --- a/libs/gui/Android.bp +++ b/libs/gui/Android.bp @@ -38,6 +38,7 @@ cc_library_shared { "BufferItemConsumer.cpp", "ConsumerBase.cpp", "CpuConsumer.cpp", + "DebugEGLImageTracker.cpp", "DisplayEventReceiver.cpp", "GLConsumer.cpp", "GuiConfig.cpp", diff --git a/libs/gui/BufferQueueProducer.cpp b/libs/gui/BufferQueueProducer.cpp index da091cc61f..d149674eeb 100644 --- a/libs/gui/BufferQueueProducer.cpp +++ b/libs/gui/BufferQueueProducer.cpp @@ -940,6 +940,15 @@ status_t BufferQueueProducer::queueBuffer(int slot, } } + // Make sure to merge the damage rect from the frame we're about + // to drop into the new frame's damage rect. + if (last.mSurfaceDamage.bounds() == Rect::INVALID_RECT || + item.mSurfaceDamage.bounds() == Rect::INVALID_RECT) { + item.mSurfaceDamage = Region::INVALID_REGION; + } else { + item.mSurfaceDamage |= last.mSurfaceDamage; + } + // Overwrite the droppable buffer with the incoming one mCore->mQueue.editItemAt(mCore->mQueue.size() - 1) = item; frameReplacedListener = mCore->mConsumerListener; diff --git a/libs/gui/DebugEGLImageTracker.cpp b/libs/gui/DebugEGLImageTracker.cpp new file mode 100644 index 0000000000..ab6f36444a --- /dev/null +++ b/libs/gui/DebugEGLImageTracker.cpp @@ -0,0 +1,98 @@ +/* + * Copyright 2019 The Android Open Source Project + * + * 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. + */ + +#include <android-base/stringprintf.h> +#include <cutils/properties.h> +#include <gui/DebugEGLImageTracker.h> + +#include <cinttypes> +#include <unordered_map> + +using android::base::StringAppendF; + +std::mutex DebugEGLImageTracker::mInstanceLock; +std::atomic<DebugEGLImageTracker *> DebugEGLImageTracker::mInstance; + +class DebugEGLImageTrackerNoOp : public DebugEGLImageTracker { +public: + DebugEGLImageTrackerNoOp() = default; + ~DebugEGLImageTrackerNoOp() override = default; + void create(const char * /*from*/) override {} + void destroy(const char * /*from*/) override {} + + void dump(std::string & /*result*/) override {} +}; + +class DebugEGLImageTrackerImpl : public DebugEGLImageTracker { +public: + DebugEGLImageTrackerImpl() = default; + ~DebugEGLImageTrackerImpl() override = default; + void create(const char * /*from*/) override; + void destroy(const char * /*from*/) override; + + void dump(std::string & /*result*/) override; + +private: + std::mutex mLock; + std::unordered_map<std::string, int64_t> mCreateTracker; + std::unordered_map<std::string, int64_t> mDestroyTracker; + + int64_t mTotalCreated = 0; + int64_t mTotalDestroyed = 0; +}; + +DebugEGLImageTracker *DebugEGLImageTracker::getInstance() { + std::lock_guard lock(mInstanceLock); + if (mInstance == nullptr) { + char value[PROPERTY_VALUE_MAX]; + property_get("debug.sf.enable_egl_image_tracker", value, "0"); + const bool enabled = static_cast<bool>(atoi(value)); + + if (enabled) { + mInstance = new DebugEGLImageTrackerImpl(); + } else { + mInstance = new DebugEGLImageTrackerNoOp(); + } + } + + return mInstance; +} + +void DebugEGLImageTrackerImpl::create(const char *from) { + std::lock_guard lock(mLock); + mCreateTracker[from]++; + mTotalCreated++; +} + +void DebugEGLImageTrackerImpl::destroy(const char *from) { + std::lock_guard lock(mLock); + mDestroyTracker[from]++; + mTotalDestroyed++; +} + +void DebugEGLImageTrackerImpl::dump(std::string &result) { + std::lock_guard lock(mLock); + StringAppendF(&result, "Live EGL Image objects: %" PRIi64 "\n", + mTotalCreated - mTotalDestroyed); + StringAppendF(&result, "Total EGL Image created: %" PRIi64 "\n", mTotalCreated); + for (const auto &[from, count] : mCreateTracker) { + StringAppendF(&result, "\t%s: %" PRIi64 "\n", from.c_str(), count); + } + StringAppendF(&result, "Total EGL Image destroyed: %" PRIi64 "\n", mTotalDestroyed); + for (const auto &[from, count] : mDestroyTracker) { + StringAppendF(&result, "\t%s: %" PRIi64 "\n", from.c_str(), count); + } +} diff --git a/libs/gui/GLConsumer.cpp b/libs/gui/GLConsumer.cpp index 8d66154bdd..8199c98582 100644 --- a/libs/gui/GLConsumer.cpp +++ b/libs/gui/GLConsumer.cpp @@ -34,6 +34,7 @@ #include <math/mat4.h> #include <gui/BufferItem.h> +#include <gui/DebugEGLImageTracker.h> #include <gui/GLConsumer.h> #include <gui/ISurfaceComposer.h> #include <gui/SurfaceComposerClient.h> @@ -944,6 +945,7 @@ GLConsumer::EglImage::~EglImage() { if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) { ALOGE("~EglImage: eglDestroyImageKHR failed"); } + DEBUG_EGL_IMAGE_TRACKER_DESTROY(); eglTerminate(mEglDisplay); } } @@ -957,6 +959,7 @@ status_t GLConsumer::EglImage::createIfNeeded(EGLDisplay eglDisplay, if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) { ALOGE("createIfNeeded: eglDestroyImageKHR failed"); } + DEBUG_EGL_IMAGE_TRACKER_DESTROY(); eglTerminate(mEglDisplay); mEglImage = EGL_NO_IMAGE_KHR; mEglDisplay = EGL_NO_DISPLAY; @@ -1006,7 +1009,10 @@ EGLImageKHR GLConsumer::EglImage::createImage(EGLDisplay dpy, EGLint error = eglGetError(); ALOGE("error creating EGLImage: %#x", error); eglTerminate(dpy); + } else { + DEBUG_EGL_IMAGE_TRACKER_CREATE(); } + return image; } diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp index e487792c87..12deaf0bd6 100644 --- a/libs/gui/ISurfaceComposer.cpp +++ b/libs/gui/ISurfaceComposer.cpp @@ -88,7 +88,7 @@ public: data.writeStrongBinder(applyToken); commands.write(data); data.writeInt64(desiredPresentTime); - data.writeWeakBinder(uncacheBuffer.token); + data.writeStrongBinder(uncacheBuffer.token.promote()); data.writeUint64(uncacheBuffer.id); if (data.writeVectorSize(listenerCallbacks) == NO_ERROR) { @@ -1036,7 +1036,7 @@ status_t BnSurfaceComposer::onTransact( int64_t desiredPresentTime = data.readInt64(); client_cache_t uncachedBuffer; - uncachedBuffer.token = data.readWeakBinder(); + uncachedBuffer.token = data.readStrongBinder(); uncachedBuffer.id = data.readUint64(); std::vector<ListenerCallbacks> listenerCallbacks; diff --git a/libs/gui/LayerState.cpp b/libs/gui/LayerState.cpp index 6066421faf..bf7991a747 100644 --- a/libs/gui/LayerState.cpp +++ b/libs/gui/LayerState.cpp @@ -87,7 +87,7 @@ status_t layer_state_t::write(Parcel& output) const colorTransform.asArray(), 16 * sizeof(float)); output.writeFloat(cornerRadius); output.writeBool(hasListenerCallbacks); - output.writeWeakBinder(cachedBuffer.token); + output.writeStrongBinder(cachedBuffer.token.promote()); output.writeUint64(cachedBuffer.id); output.writeParcelable(metadata); @@ -157,7 +157,7 @@ status_t layer_state_t::read(const Parcel& input) colorTransform = mat4(static_cast<const float*>(input.readInplace(16 * sizeof(float)))); cornerRadius = input.readFloat(); hasListenerCallbacks = input.readBool(); - cachedBuffer.token = input.readWeakBinder(); + cachedBuffer.token = input.readStrongBinder(); cachedBuffer.id = input.readUint64(); input.readParcelable(&metadata); @@ -267,8 +267,9 @@ void layer_state_t::merge(const layer_state_t& other) { } if (other.what & eFlagsChanged) { what |= eFlagsChanged; - flags = other.flags; - mask = other.mask; + flags &= ~other.mask; + flags |= (other.flags & other.mask); + mask |= other.mask; } if (other.what & eLayerStackChanged) { what |= eLayerStackChanged; diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp index c59fddfb9d..16a4b353aa 100644 --- a/libs/gui/SurfaceComposerClient.cpp +++ b/libs/gui/SurfaceComposerClient.cpp @@ -448,6 +448,7 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::merge(Tr mInputWindowCommands.merge(other.mInputWindowCommands); mContainsBuffer = other.mContainsBuffer; + mEarlyWakeup = mEarlyWakeup || other.mEarlyWakeup; other.clear(); return *this; } diff --git a/libs/gui/include/gui/DebugEGLImageTracker.h b/libs/gui/include/gui/DebugEGLImageTracker.h new file mode 100644 index 0000000000..5d369c9a35 --- /dev/null +++ b/libs/gui/include/gui/DebugEGLImageTracker.h @@ -0,0 +1,44 @@ +/* + * Copyright 2019 The Android Open Source Project + * + * 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. + */ + +#pragma once + +#include <atomic> +#include <mutex> +#include <string> + +class DebugEGLImageTracker { +public: + static DebugEGLImageTracker *getInstance(); + + virtual void create(const char *from) = 0; + virtual void destroy(const char *from) = 0; + + virtual void dump(std::string &result) = 0; + +protected: + DebugEGLImageTracker() = default; + virtual ~DebugEGLImageTracker() = default; + DebugEGLImageTracker(const DebugEGLImageTracker &) = delete; + + static std::mutex mInstanceLock; + static std::atomic<DebugEGLImageTracker *> mInstance; +}; + +#define DEBUG_EGL_IMAGE_TRACKER_CREATE() \ + (DebugEGLImageTracker::getInstance()->create(__PRETTY_FUNCTION__)) +#define DEBUG_EGL_IMAGE_TRACKER_DESTROY() \ + (DebugEGLImageTracker::getInstance()->destroy(__PRETTY_FUNCTION__))
\ No newline at end of file diff --git a/libs/gui/include/gui/ITransactionCompletedListener.h b/libs/gui/include/gui/ITransactionCompletedListener.h index 774ad46b15..cbfd365692 100644 --- a/libs/gui/include/gui/ITransactionCompletedListener.h +++ b/libs/gui/include/gui/ITransactionCompletedListener.h @@ -106,6 +106,16 @@ public: const std::vector<CallbackId>& ids) : transactionCompletedListener(listener), callbackIds(ids) {} + bool operator==(const ListenerCallbacks& rhs) const { + if (transactionCompletedListener != rhs.transactionCompletedListener) { + return false; + } + if (callbackIds.empty()) { + return rhs.callbackIds.empty(); + } + return callbackIds.front() == rhs.callbackIds.front(); + } + sp<ITransactionCompletedListener> transactionCompletedListener; std::vector<CallbackId> callbackIds; }; diff --git a/libs/renderengine/gl/GLESRenderEngine.cpp b/libs/renderengine/gl/GLESRenderEngine.cpp index 6e7ec336e9..8bfd3dd9ee 100644 --- a/libs/renderengine/gl/GLESRenderEngine.cpp +++ b/libs/renderengine/gl/GLESRenderEngine.cpp @@ -31,6 +31,7 @@ #include <android-base/stringprintf.h> #include <cutils/compiler.h> #include <cutils/properties.h> +#include <gui/DebugEGLImageTracker.h> #include <renderengine/Mesh.h> #include <renderengine/Texture.h> #include <renderengine/private/Description.h> @@ -433,6 +434,7 @@ GLESRenderEngine::~GLESRenderEngine() { EGLImageKHR expired = mFramebufferImageCache.front().second; mFramebufferImageCache.pop_front(); eglDestroyImageKHR(mEGLDisplay, expired); + DEBUG_EGL_IMAGE_TRACKER_DESTROY(); } mImageCache.clear(); eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); @@ -610,63 +612,28 @@ void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& i } } -status_t GLESRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) { - std::lock_guard<std::mutex> lock(mRenderingMutex); - return cacheExternalTextureBufferLocked(buffer); -} - status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName, const sp<GraphicBuffer>& buffer, const sp<Fence>& bufferFence) { - std::lock_guard<std::mutex> lock(mRenderingMutex); - return bindExternalTextureBufferLocked(texName, buffer, bufferFence); -} - -status_t GLESRenderEngine::cacheExternalTextureBufferLocked(const sp<GraphicBuffer>& buffer) { - if (buffer == nullptr) { - return BAD_VALUE; - } - ATRACE_CALL(); - - if (mImageCache.count(buffer->getId()) > 0) { - return NO_ERROR; - } - - std::unique_ptr<Image> newImage = createImage(); - - bool created = newImage->setNativeWindowBuffer(buffer->getNativeBuffer(), - buffer->getUsage() & GRALLOC_USAGE_PROTECTED); - if (!created) { - ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d", - buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(), - buffer->getPixelFormat()); - return NO_INIT; - } - mImageCache.insert(std::make_pair(buffer->getId(), std::move(newImage))); - - return NO_ERROR; -} - -status_t GLESRenderEngine::bindExternalTextureBufferLocked(uint32_t texName, - const sp<GraphicBuffer>& buffer, - const sp<Fence>& bufferFence) { - ATRACE_CALL(); - status_t cacheResult = cacheExternalTextureBufferLocked(buffer); + status_t cacheResult = cacheExternalTextureBuffer(buffer); if (cacheResult != NO_ERROR) { return cacheResult; } - auto cachedImage = mImageCache.find(buffer->getId()); + { + std::lock_guard<std::mutex> lock(mRenderingMutex); + auto cachedImage = mImageCache.find(buffer->getId()); - if (cachedImage == mImageCache.end()) { - // We failed creating the image if we got here, so bail out. - bindExternalTextureImage(texName, *createImage()); - return NO_INIT; - } + if (cachedImage == mImageCache.end()) { + // We failed creating the image if we got here, so bail out. + bindExternalTextureImage(texName, *createImage()); + return NO_INIT; + } - bindExternalTextureImage(texName, *cachedImage->second); + bindExternalTextureImage(texName, *cachedImage->second); + } // Wait for the new buffer to be ready. if (bufferFence != nullptr && bufferFence->isValid()) { @@ -692,6 +659,45 @@ status_t GLESRenderEngine::bindExternalTextureBufferLocked(uint32_t texName, return NO_ERROR; } +status_t GLESRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) { + if (buffer == nullptr) { + return BAD_VALUE; + } + + { + std::lock_guard<std::mutex> lock(mRenderingMutex); + if (mImageCache.count(buffer->getId()) > 0) { + // If there's already an image then fail fast here. + return NO_ERROR; + } + } + ATRACE_CALL(); + + // Create the image without holding a lock so that we don't block anything. + std::unique_ptr<Image> newImage = createImage(); + + bool created = newImage->setNativeWindowBuffer(buffer->getNativeBuffer(), + buffer->getUsage() & GRALLOC_USAGE_PROTECTED); + if (!created) { + ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d", + buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(), + buffer->getPixelFormat()); + return NO_INIT; + } + + { + std::lock_guard<std::mutex> lock(mRenderingMutex); + if (mImageCache.count(buffer->getId()) > 0) { + // In theory it's possible for another thread to recache the image, + // so bail out if another thread won. + return NO_ERROR; + } + mImageCache.insert(std::make_pair(buffer->getId(), std::move(newImage))); + } + + return NO_ERROR; +} + void GLESRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) { std::lock_guard<std::mutex> lock(mRenderingMutex); const auto& cachedImage = mImageCache.find(bufferId); @@ -837,6 +843,7 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer bool useFramebufferCache) { sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(nativeBuffer); if (useFramebufferCache) { + std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex); for (const auto& image : mFramebufferImageCache) { if (image.first == graphicBuffer->getId()) { return image.second; @@ -852,14 +859,20 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer nativeBuffer, attributes); if (useFramebufferCache) { if (image != EGL_NO_IMAGE_KHR) { + std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex); if (mFramebufferImageCache.size() >= mFramebufferImageCacheSize) { EGLImageKHR expired = mFramebufferImageCache.front().second; mFramebufferImageCache.pop_front(); eglDestroyImageKHR(mEGLDisplay, expired); + DEBUG_EGL_IMAGE_TRACKER_DESTROY(); } mFramebufferImageCache.push_back({graphicBuffer->getId(), image}); } } + + if (image != EGL_NO_IMAGE_KHR) { + DEBUG_EGL_IMAGE_TRACKER_CREATE(); + } return image; } @@ -884,127 +897,123 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, return BAD_VALUE; } - { - std::lock_guard<std::mutex> lock(mRenderingMutex); - - BindNativeBufferAsFramebuffer fbo(*this, buffer, useFramebufferCache); + BindNativeBufferAsFramebuffer fbo(*this, buffer, useFramebufferCache); - if (fbo.getStatus() != NO_ERROR) { - ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).", - buffer->handle); - checkErrors(); - return fbo.getStatus(); - } - - // clear the entire buffer, sometimes when we reuse buffers we'd persist - // ghost images otherwise. - // we also require a full transparent framebuffer for overlays. This is - // probably not quite efficient on all GPUs, since we could filter out - // opaque layers. - clearWithColor(0.0, 0.0, 0.0, 0.0); + if (fbo.getStatus() != NO_ERROR) { + ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).", + buffer->handle); + checkErrors(); + return fbo.getStatus(); + } - setViewportAndProjection(display.physicalDisplay, display.clip); + // clear the entire buffer, sometimes when we reuse buffers we'd persist + // ghost images otherwise. + // we also require a full transparent framebuffer for overlays. This is + // probably not quite efficient on all GPUs, since we could filter out + // opaque layers. + clearWithColor(0.0, 0.0, 0.0, 0.0); - setOutputDataSpace(display.outputDataspace); - setDisplayMaxLuminance(display.maxLuminance); + setViewportAndProjection(display.physicalDisplay, display.clip); - mat4 projectionMatrix = mState.projectionMatrix * display.globalTransform; - mState.projectionMatrix = projectionMatrix; - if (!display.clearRegion.isEmpty()) { - glDisable(GL_BLEND); - fillRegionWithColor(display.clearRegion, 0.0, 0.0, 0.0, 1.0); - } + setOutputDataSpace(display.outputDataspace); + setDisplayMaxLuminance(display.maxLuminance); - Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2, 2); - for (auto layer : layers) { - mState.projectionMatrix = projectionMatrix * layer.geometry.positionTransform; + mat4 projectionMatrix = mState.projectionMatrix * display.globalTransform; + mState.projectionMatrix = projectionMatrix; + if (!display.clearRegion.isEmpty()) { + glDisable(GL_BLEND); + fillRegionWithColor(display.clearRegion, 0.0, 0.0, 0.0, 1.0); + } - const FloatRect bounds = layer.geometry.boundaries; - Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); - position[0] = vec2(bounds.left, bounds.top); - position[1] = vec2(bounds.left, bounds.bottom); - position[2] = vec2(bounds.right, bounds.bottom); - position[3] = vec2(bounds.right, bounds.top); + Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2, 2); + for (auto layer : layers) { + mState.projectionMatrix = projectionMatrix * layer.geometry.positionTransform; - setupLayerCropping(layer, mesh); - setColorTransform(display.colorTransform * layer.colorTransform); + const FloatRect bounds = layer.geometry.boundaries; + Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); + position[0] = vec2(bounds.left, bounds.top); + position[1] = vec2(bounds.left, bounds.bottom); + position[2] = vec2(bounds.right, bounds.bottom); + position[3] = vec2(bounds.right, bounds.top); - bool usePremultipliedAlpha = true; - bool disableTexture = true; - bool isOpaque = false; + setupLayerCropping(layer, mesh); + setColorTransform(display.colorTransform * layer.colorTransform); - if (layer.source.buffer.buffer != nullptr) { - disableTexture = false; - isOpaque = layer.source.buffer.isOpaque; + bool usePremultipliedAlpha = true; + bool disableTexture = true; + bool isOpaque = false; - sp<GraphicBuffer> gBuf = layer.source.buffer.buffer; - bindExternalTextureBufferLocked(layer.source.buffer.textureName, gBuf, - layer.source.buffer.fence); + if (layer.source.buffer.buffer != nullptr) { + disableTexture = false; + isOpaque = layer.source.buffer.isOpaque; - usePremultipliedAlpha = layer.source.buffer.usePremultipliedAlpha; - Texture texture(Texture::TEXTURE_EXTERNAL, layer.source.buffer.textureName); - mat4 texMatrix = layer.source.buffer.textureTransform; + sp<GraphicBuffer> gBuf = layer.source.buffer.buffer; + bindExternalTextureBuffer(layer.source.buffer.textureName, gBuf, + layer.source.buffer.fence); - texture.setMatrix(texMatrix.asArray()); - texture.setFiltering(layer.source.buffer.useTextureFiltering); + usePremultipliedAlpha = layer.source.buffer.usePremultipliedAlpha; + Texture texture(Texture::TEXTURE_EXTERNAL, layer.source.buffer.textureName); + mat4 texMatrix = layer.source.buffer.textureTransform; - texture.setDimensions(gBuf->getWidth(), gBuf->getHeight()); - setSourceY410BT2020(layer.source.buffer.isY410BT2020); + texture.setMatrix(texMatrix.asArray()); + texture.setFiltering(layer.source.buffer.useTextureFiltering); - renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>()); - texCoords[0] = vec2(0.0, 0.0); - texCoords[1] = vec2(0.0, 1.0); - texCoords[2] = vec2(1.0, 1.0); - texCoords[3] = vec2(1.0, 0.0); - setupLayerTexturing(texture); - } + texture.setDimensions(gBuf->getWidth(), gBuf->getHeight()); + setSourceY410BT2020(layer.source.buffer.isY410BT2020); - const half3 solidColor = layer.source.solidColor; - const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer.alpha); - // Buffer sources will have a black solid color ignored in the shader, - // so in that scenario the solid color passed here is arbitrary. - setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color, - layer.geometry.roundedCornersRadius); - if (layer.disableBlending) { - glDisable(GL_BLEND); - } - setSourceDataSpace(layer.sourceDataspace); - - // We only want to do a special handling for rounded corners when having rounded corners - // is the only reason it needs to turn on blending, otherwise, we handle it like the - // usual way since it needs to turn on blending anyway. - if (layer.geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) { - handleRoundedCorners(display, layer, mesh); - } else { - drawMesh(mesh); - } + renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>()); + texCoords[0] = vec2(0.0, 0.0); + texCoords[1] = vec2(0.0, 1.0); + texCoords[2] = vec2(1.0, 1.0); + texCoords[3] = vec2(1.0, 0.0); + setupLayerTexturing(texture); + } - // Cleanup if there's a buffer source - if (layer.source.buffer.buffer != nullptr) { - disableBlending(); - setSourceY410BT2020(false); - disableTexturing(); - } + const half3 solidColor = layer.source.solidColor; + const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer.alpha); + // Buffer sources will have a black solid color ignored in the shader, + // so in that scenario the solid color passed here is arbitrary. + setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color, + layer.geometry.roundedCornersRadius); + if (layer.disableBlending) { + glDisable(GL_BLEND); } + setSourceDataSpace(layer.sourceDataspace); - if (drawFence != nullptr) { - *drawFence = flush(); + // We only want to do a special handling for rounded corners when having rounded corners + // is the only reason it needs to turn on blending, otherwise, we handle it like the + // usual way since it needs to turn on blending anyway. + if (layer.geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) { + handleRoundedCorners(display, layer, mesh); + } else { + drawMesh(mesh); } - // If flush failed or we don't support native fences, we need to force the - // gl command stream to be executed. - if (drawFence == nullptr || drawFence->get() < 0) { - bool success = finish(); - if (!success) { - ALOGE("Failed to flush RenderEngine commands"); - checkErrors(); - // Chances are, something illegal happened (either the caller passed - // us bad parameters, or we messed up our shader generation). - return INVALID_OPERATION; - } + + // Cleanup if there's a buffer source + if (layer.source.buffer.buffer != nullptr) { + disableBlending(); + setSourceY410BT2020(false); + disableTexturing(); } + } - checkErrors(); + if (drawFence != nullptr) { + *drawFence = flush(); + } + // If flush failed or we don't support native fences, we need to force the + // gl command stream to be executed. + if (drawFence == nullptr || drawFence->get() < 0) { + bool success = finish(); + if (!success) { + ALOGE("Failed to flush RenderEngine commands"); + checkErrors(); + // Chances are, something illegal happened (either the caller passed + // us bad parameters, or we messed up our shader generation). + return INVALID_OPERATION; + } } + + checkErrors(); return NO_ERROR; } @@ -1266,6 +1275,23 @@ void GLESRenderEngine::dump(std::string& result) { StringAppendF(&result, "RenderEngine last dataspace conversion: (%s) to (%s)\n", dataspaceDetails(static_cast<android_dataspace>(mDataSpace)).c_str(), dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str()); + { + std::lock_guard<std::mutex> lock(mRenderingMutex); + StringAppendF(&result, "RenderEngine image cache size: %zu\n", mImageCache.size()); + StringAppendF(&result, "Dumping buffer ids...\n"); + for (const auto& [id, unused] : mImageCache) { + StringAppendF(&result, "0x%" PRIx64 "\n", id); + } + } + { + std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex); + StringAppendF(&result, "RenderEngine framebuffer image cache size: %zu\n", + mFramebufferImageCache.size()); + StringAppendF(&result, "Dumping buffer ids...\n"); + for (const auto& [id, unused] : mFramebufferImageCache) { + StringAppendF(&result, "0x%" PRIx64 "\n", id); + } + } } GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str) { @@ -1392,7 +1418,7 @@ bool GLESRenderEngine::isImageCachedForTesting(uint64_t bufferId) { } bool GLESRenderEngine::isFramebufferImageCachedForTesting(uint64_t bufferId) { - std::lock_guard<std::mutex> lock(mRenderingMutex); + std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex); return std::any_of(mFramebufferImageCache.cbegin(), mFramebufferImageCache.cend(), [=](std::pair<uint64_t, EGLImageKHR> image) { return image.first == bufferId; diff --git a/libs/renderengine/gl/GLESRenderEngine.h b/libs/renderengine/gl/GLESRenderEngine.h index 70b704abce..c8b45d2a0b 100644 --- a/libs/renderengine/gl/GLESRenderEngine.h +++ b/libs/renderengine/gl/GLESRenderEngine.h @@ -73,23 +73,25 @@ public: bool useProtectedContext(bool useProtectedContext) override; status_t drawLayers(const DisplaySettings& display, const std::vector<LayerSettings>& layers, ANativeWindowBuffer* buffer, const bool useFramebufferCache, - base::unique_fd&& bufferFence, base::unique_fd* drawFence) - EXCLUDES(mRenderingMutex) override; + base::unique_fd&& bufferFence, base::unique_fd* drawFence) override; EGLDisplay getEGLDisplay() const { return mEGLDisplay; } // Creates an output image for rendering to EGLImageKHR createFramebufferImageIfNeeded(ANativeWindowBuffer* nativeBuffer, bool isProtected, - bool useFramebufferCache); + bool useFramebufferCache) + EXCLUDES(mFramebufferImageCacheMutex); // Test-only methods // Returns true iff mImageCache contains an image keyed by bufferId bool isImageCachedForTesting(uint64_t bufferId) EXCLUDES(mRenderingMutex); // Returns true iff mFramebufferImageCache contains an image keyed by bufferId - bool isFramebufferImageCachedForTesting(uint64_t bufferId) EXCLUDES(mRenderingMutex); + bool isFramebufferImageCachedForTesting(uint64_t bufferId) + EXCLUDES(mFramebufferImageCacheMutex); protected: Framebuffer* getFramebufferForDrawing() override; - void dump(std::string& result) override; + void dump(std::string& result) override EXCLUDES(mRenderingMutex) + EXCLUDES(mFramebufferImageCacheMutex); size_t getMaxTextureSize() const override; size_t getMaxViewportDims() const override; @@ -191,7 +193,11 @@ private: uint32_t mFramebufferImageCacheSize = 0; // Cache of output images, keyed by corresponding GraphicBuffer ID. - std::deque<std::pair<uint64_t, EGLImageKHR>> mFramebufferImageCache; + std::deque<std::pair<uint64_t, EGLImageKHR>> mFramebufferImageCache + GUARDED_BY(mFramebufferImageCacheMutex); + // The only reason why we have this mutex is so that we don't segfault when + // dumping info. + std::mutex mFramebufferImageCacheMutex; // Current dataspace of layer being rendered ui::Dataspace mDataSpace = ui::Dataspace::UNKNOWN; @@ -211,15 +217,6 @@ private: // multiple threads is guaranteed thread-safe. std::mutex mRenderingMutex; - // See bindExternalTextureBuffer above, but requiring that mRenderingMutex - // is held. - status_t bindExternalTextureBufferLocked(uint32_t texName, const sp<GraphicBuffer>& buffer, - const sp<Fence>& fence) REQUIRES(mRenderingMutex); - // See cacheExternalTextureBuffer above, but requiring that mRenderingMutex - // is held. - status_t cacheExternalTextureBufferLocked(const sp<GraphicBuffer>& buffer) - REQUIRES(mRenderingMutex); - std::unique_ptr<Framebuffer> mDrawingBuffer; class FlushTracer { diff --git a/libs/renderengine/gl/GLFramebuffer.cpp b/libs/renderengine/gl/GLFramebuffer.cpp index dacf8d3d82..5fbb5ba7d7 100644 --- a/libs/renderengine/gl/GLFramebuffer.cpp +++ b/libs/renderengine/gl/GLFramebuffer.cpp @@ -22,6 +22,7 @@ #include <GLES/glext.h> #include <GLES2/gl2.h> #include <GLES2/gl2ext.h> +#include <gui/DebugEGLImageTracker.h> #include <nativebase/nativebase.h> #include <utils/Trace.h> #include "GLESRenderEngine.h" @@ -47,6 +48,7 @@ bool GLFramebuffer::setNativeWindowBuffer(ANativeWindowBuffer* nativeBuffer, boo if (mEGLImage != EGL_NO_IMAGE_KHR) { if (!usingFramebufferCache) { eglDestroyImageKHR(mEGLDisplay, mEGLImage); + DEBUG_EGL_IMAGE_TRACKER_DESTROY(); } mEGLImage = EGL_NO_IMAGE_KHR; mBufferWidth = 0; diff --git a/libs/renderengine/gl/GLImage.cpp b/libs/renderengine/gl/GLImage.cpp index 77e648e70f..8497721956 100644 --- a/libs/renderengine/gl/GLImage.cpp +++ b/libs/renderengine/gl/GLImage.cpp @@ -20,6 +20,7 @@ #include <vector> +#include <gui/DebugEGLImageTracker.h> #include <log/log.h> #include <utils/Trace.h> #include "GLESRenderEngine.h" @@ -58,6 +59,7 @@ bool GLImage::setNativeWindowBuffer(ANativeWindowBuffer* buffer, bool isProtecte if (!eglDestroyImageKHR(mEGLDisplay, mEGLImage)) { ALOGE("failed to destroy image: %#x", eglGetError()); } + DEBUG_EGL_IMAGE_TRACKER_DESTROY(); mEGLImage = EGL_NO_IMAGE_KHR; } @@ -69,6 +71,7 @@ bool GLImage::setNativeWindowBuffer(ANativeWindowBuffer* buffer, bool isProtecte ALOGE("failed to create EGLImage: %#x", eglGetError()); return false; } + DEBUG_EGL_IMAGE_TRACKER_CREATE(); mProtected = isProtected; } diff --git a/libs/renderengine/include/renderengine/RenderEngine.h b/libs/renderengine/include/renderengine/RenderEngine.h index 8a798eefd1..1c480a7bce 100644 --- a/libs/renderengine/include/renderengine/RenderEngine.h +++ b/libs/renderengine/include/renderengine/RenderEngine.h @@ -120,6 +120,17 @@ public: // should be called for every display that needs to be rendered via the GPU. // @param display The display-wide settings that should be applied prior to // drawing any layers. + // + // Assumptions when calling this method: + // 1. There is exactly one caller - i.e. multi-threading is not supported. + // 2. Additional threads may be calling the {bind,cache}ExternalTexture + // methods above. But the main thread is responsible for holding resources + // such that Image destruction does not occur while this method is called. + // + // TODO(b/136806342): This should behavior should ideally be fixed since + // the above two assumptions are brittle, as conditional thread safetyness + // may be insufficient when maximizing rendering performance in the future. + // // @param layers The layers to draw onto the display, in Z-order. // @param buffer The buffer which will be drawn to. This buffer will be // ready once drawFence fires. diff --git a/libs/ui/Android.bp b/libs/ui/Android.bp index 0407d8802c..2cc6857744 100644 --- a/libs/ui/Android.bp +++ b/libs/ui/Android.bp @@ -95,7 +95,6 @@ cc_library_shared { "android.hardware.graphics.mapper@3.0", "libbase", "libcutils", - "libhardware", "libhidlbase", "libhidltransport", "libhwbinder", diff --git a/libs/ui/GraphicBufferAllocator.cpp b/libs/ui/GraphicBufferAllocator.cpp index 0861a1f9a3..9c7d1fda90 100644 --- a/libs/ui/GraphicBufferAllocator.cpp +++ b/libs/ui/GraphicBufferAllocator.cpp @@ -20,6 +20,7 @@ #include <ui/GraphicBufferAllocator.h> +#include <limits.h> #include <stdio.h> #include <grallocusage/GrallocUsageConversion.h> @@ -114,6 +115,14 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, if (!width || !height) width = height = 1; + const uint32_t bpp = bytesPerPixel(format); + if (std::numeric_limits<size_t>::max() / width / height < static_cast<size_t>(bpp)) { + ALOGE("Failed to allocate (%u x %u) layerCount %u format %d " + "usage %" PRIx64 ": Requesting too large a buffer size", + width, height, layerCount, format, usage); + return BAD_VALUE; + } + // Ensure that layerCount is valid. if (layerCount < 1) layerCount = 1; @@ -126,7 +135,6 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, if (error == NO_ERROR) { Mutex::Autolock _l(sLock); KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList); - uint32_t bpp = bytesPerPixel(format); alloc_rec_t rec; rec.width = width; rec.height = height; diff --git a/libs/ui/tests/GraphicBuffer_test.cpp b/libs/ui/tests/GraphicBuffer_test.cpp index a7c248c105..127f7eedd6 100644 --- a/libs/ui/tests/GraphicBuffer_test.cpp +++ b/libs/ui/tests/GraphicBuffer_test.cpp @@ -35,6 +35,22 @@ constexpr uint64_t kTestUsage = GraphicBuffer::USAGE_SW_WRITE_OFTEN; class GraphicBufferTest : public testing::Test {}; +TEST_F(GraphicBufferTest, AllocateNoError) { + PixelFormat format = PIXEL_FORMAT_RGBA_8888; + sp<GraphicBuffer> gb(new GraphicBuffer(kTestWidth, kTestHeight, format, kTestLayerCount, + kTestUsage, std::string("test"))); + ASSERT_EQ(NO_ERROR, gb->initCheck()); +} + +TEST_F(GraphicBufferTest, AllocateBadDimensions) { + PixelFormat format = PIXEL_FORMAT_RGBA_8888; + uint32_t width, height; + width = height = std::numeric_limits<uint32_t>::max(); + sp<GraphicBuffer> gb(new GraphicBuffer(width, height, format, kTestLayerCount, kTestUsage, + std::string("test"))); + ASSERT_EQ(BAD_VALUE, gb->initCheck()); +} + TEST_F(GraphicBufferTest, CreateFromBufferHubBuffer) { std::unique_ptr<BufferHubBuffer> b1 = BufferHubBuffer::create(kTestWidth, kTestHeight, kTestLayerCount, kTestFormat, diff --git a/libs/vr/libbufferhubqueue/Android.bp b/libs/vr/libbufferhubqueue/Android.bp index 9f72c05f0c..77c79112de 100644 --- a/libs/vr/libbufferhubqueue/Android.bp +++ b/libs/vr/libbufferhubqueue/Android.bp @@ -26,10 +26,8 @@ staticLibraries = [ ] sharedLibraries = [ - "libbase", "libbinder", "libcutils", - "libhardware", "liblog", "libui", "libutils", diff --git a/services/gpuservice/GpuService.cpp b/services/gpuservice/GpuService.cpp index c81ab509c3..e50dfca0a1 100644 --- a/services/gpuservice/GpuService.cpp +++ b/services/gpuservice/GpuService.cpp @@ -28,7 +28,12 @@ #include <utils/String8.h> #include <utils/Trace.h> +#include <array> +#include <fstream> +#include <sstream> +#include <sys/types.h> #include <vkjson.h> +#include <unistd.h> #include "gpustats/GpuStats.h" @@ -40,6 +45,7 @@ namespace { status_t cmdHelp(int out); status_t cmdVkjson(int out, int err); void dumpGameDriverInfo(std::string* result); +void dumpMemoryInfo(std::string* result, const GpuMemoryMap& memories, uint32_t pid); } // namespace const String16 sDump("android.permission.DUMP"); @@ -72,6 +78,147 @@ void GpuService::setTargetStats(const std::string& appPackageName, const uint64_ mGpuStats->insertTargetStats(appPackageName, driverVersionCode, stats, value); } +bool isExpectedFormat(const char* str) { + // Should match in order: + // gpuaddr useraddr size id flags type usage sglen mapsize eglsrf eglimg + std::istringstream iss; + iss.str(str); + + std::string word; + iss >> word; + if (word != "gpuaddr") { return false; } + iss >> word; + if (word != "useraddr") { return false; } + iss >> word; + if (word != "size") { return false; } + iss >> word; + if (word != "id") { return false; } + iss >> word; + if (word != "flags") { return false; } + iss >> word; + if (word != "type") { return false; } + iss >> word; + if (word != "usage") { return false; } + iss >> word; + if (word != "sglen") { return false; } + iss >> word; + if (word != "mapsize") { return false; } + iss >> word; + if (word != "eglsrf") { return false; } + iss >> word; + if (word != "eglimg") { return false; } + return true; +} + + +// Queries gpu memory via Qualcomm's /d/kgsl/proc/*/mem interface. +status_t GpuService::getQCommGpuMemoryInfo(GpuMemoryMap* memories, std::string* result, int32_t dumpPid) const { + const std::string kDirectoryPath = "/d/kgsl/proc"; + DIR* directory = opendir(kDirectoryPath.c_str()); + if (!directory) { return PERMISSION_DENIED; } + + // File Format: + // gpuaddr useraddr size id flags type usage sglen mapsize eglsrf eglimg + // 0000000000000000 0000000000000000 8359936 23 --w--pY-- gpumem VK/others( 38) 0 0 0 0 + // 0000000000000000 0000000000000000 16293888 24 --wL--N-- ion surface 41 0 0 1 + + const bool dumpAll = dumpPid == 0; + static constexpr size_t kMaxLineLength = 1024; + static char line[kMaxLineLength]; + while(dirent* subdir = readdir(directory)) { + // Skip "." and ".." in directory. + if (strcmp(subdir->d_name, ".") == 0 || strcmp(subdir->d_name, "..") == 0 ) { continue; } + + std::string pid_str(subdir->d_name); + const uint32_t pid(stoi(pid_str)); + + if (!dumpAll && dumpPid != pid) { + continue; + } + + std::string filepath(kDirectoryPath + "/" + pid_str + "/mem"); + std::ifstream file(filepath); + + // Check first line + file.getline(line, kMaxLineLength); + if (!isExpectedFormat(line)) { + continue; + } + + if (result) { + StringAppendF(result, "%d:\n%s\n", pid, line); + } + + while( file.getline(line, kMaxLineLength) ) { + if (result) { + StringAppendF(result, "%s\n", line); + } + + std::istringstream iss; + iss.str(line); + + // Skip gpuaddr, useraddr. + const char delimiter = ' '; + iss >> std::ws; + iss.ignore(kMaxLineLength, delimiter); + iss >> std::ws; + iss.ignore(kMaxLineLength, delimiter); + + // Get size. + int64_t memsize; + iss >> memsize; + + // Skip id, flags. + iss >> std::ws; + iss.ignore(kMaxLineLength, delimiter); + iss >> std::ws; + iss.ignore(kMaxLineLength, delimiter); + + // Get type, usage. + std::string memtype; + std::string usage; + iss >> memtype >> usage; + + // Adjust for the space in VK/others( #) + if (usage == "VK/others(") { + std::string vkTypeEnd; + iss >> vkTypeEnd; + usage.append(vkTypeEnd); + } + + // Skip sglen. + iss >> std::ws; + iss.ignore(kMaxLineLength, delimiter); + + // Get mapsize. + int64_t mapsize; + iss >> mapsize; + + if (memsize == 0 && mapsize == 0) { + continue; + } + + if (memtype == "gpumem") { + (*memories)[pid][usage].gpuMemory += memsize; + } else { + (*memories)[pid][usage].ionMemory += memsize; + } + + if (mapsize > 0) { + (*memories)[pid][usage].mappedMemory += mapsize; + } + } + + if (result) { + StringAppendF(result, "\n"); + } + } + + closedir(directory); + + return OK; +} + status_t GpuService::shellCommand(int /*in*/, int out, int err, std::vector<String16>& args) { ATRACE_CALL(); @@ -99,24 +246,44 @@ status_t GpuService::doDump(int fd, const Vector<String16>& args, bool /*asProto StringAppendF(&result, "Permission Denial: can't dump gpu from pid=%d, uid=%d\n", pid, uid); } else { bool dumpAll = true; - size_t index = 0; + bool dumpDriverInfo = false; + bool dumpStats = false; + bool dumpMemory = false; size_t numArgs = args.size(); + int32_t pid = 0; if (numArgs) { - if ((index < numArgs) && (args[index] == String16("--gpustats"))) { - index++; - mGpuStats->dump(args, &result); - dumpAll = false; + dumpAll = false; + for (size_t index = 0; index < numArgs; ++index) { + if (args[index] == String16("--gpustats")) { + dumpStats = true; + } else if (args[index] == String16("--gpudriverinfo")) { + dumpDriverInfo = true; + } else if (args[index] == String16("--gpumem")) { + dumpMemory = true; + } else if (args[index].compare(String16("--gpumem=")) > 0) { + dumpMemory = true; + pid = atoi(String8(&args[index][9])); + } } } - if (dumpAll) { + if (dumpAll || dumpDriverInfo) { dumpGameDriverInfo(&result); result.append("\n"); - + } + if (dumpAll || dumpStats) { mGpuStats->dump(Vector<String16>(), &result); result.append("\n"); } + if (dumpAll || dumpMemory) { + GpuMemoryMap memories; + // Currently only queries Qualcomm gpu memory. More will be added later. + if (getQCommGpuMemoryInfo(&memories, &result, pid) == OK) { + dumpMemoryInfo(&result, memories, pid); + result.append("\n"); + } + } } write(fd, result.c_str(), result.size()); @@ -168,6 +335,34 @@ void dumpGameDriverInfo(std::string* result) { StringAppendF(result, "Pre-release Game Driver: %s\n", preReleaseGameDriver); } +// Read and print all memory info for each process from /d/kgsl/proc/<pid>/mem. +void dumpMemoryInfo(std::string* result, const GpuMemoryMap& memories, uint32_t pid) { + if (!result) return; + + // Write results. + StringAppendF(result, "GPU Memory Summary:\n"); + for(auto& mem : memories) { + uint32_t process = mem.first; + if (pid != 0 && pid != process) { + continue; + } + + StringAppendF(result, "%d:\n", process); + for(auto& memStruct : mem.second) { + StringAppendF(result, " %s", memStruct.first.c_str()); + + if(memStruct.second.gpuMemory > 0) + StringAppendF(result, ", GPU memory = %" PRId64, memStruct.second.gpuMemory); + if(memStruct.second.mappedMemory > 0) + StringAppendF(result, ", Mapped memory = %" PRId64, memStruct.second.mappedMemory); + if(memStruct.second.ionMemory > 0) + StringAppendF(result, ", Ion memory = %" PRId64, memStruct.second.ionMemory); + + StringAppendF(result, "\n"); + } + } +} + } // anonymous namespace } // namespace android diff --git a/services/gpuservice/GpuService.h b/services/gpuservice/GpuService.h index 525fb4fada..b3dc2e2718 100644 --- a/services/gpuservice/GpuService.h +++ b/services/gpuservice/GpuService.h @@ -25,11 +25,22 @@ #include <mutex> #include <vector> +#include <unordered_map> namespace android { class GpuStats; +struct MemoryStruct { + int64_t gpuMemory; + int64_t mappedMemory; + int64_t ionMemory; +}; + +// A map that keeps track of how much memory of each type is allocated by every process. +// Format: map[pid][memoryType] = MemoryStruct()' +using GpuMemoryMap = std::unordered_map<int32_t, std::unordered_map<std::string, MemoryStruct>>; + class GpuService : public BnGpuService, public PriorityDumper { public: static const char* const SERVICE_NAME ANDROID_API; @@ -71,6 +82,8 @@ private: status_t doDump(int fd, const Vector<String16>& args, bool asProto); + status_t getQCommGpuMemoryInfo(GpuMemoryMap* memories, std::string* result, int32_t dumpPid) const; + /* * Attributes */ diff --git a/services/inputflinger/EventHub.h b/services/inputflinger/EventHub.h index eb4e8f2e50..6c3a4a2aa3 100644 --- a/services/inputflinger/EventHub.h +++ b/services/inputflinger/EventHub.h @@ -146,12 +146,11 @@ extern uint32_t getAbsAxisUsage(int32_t axis, uint32_t deviceClasses); * which keys are currently down. Finally, the event hub keeps track of the capabilities of * individual input devices, such as their class and the set of key codes that they support. */ -class EventHubInterface : public virtual RefBase { -protected: +class EventHubInterface { +public: EventHubInterface() { } virtual ~EventHubInterface() { } -public: // Synthetic raw event type codes produced when devices are added or removed. enum { // Sent when a device is added. @@ -319,7 +318,6 @@ public: virtual void dump(std::string& dump); virtual void monitor(); -protected: virtual ~EventHub(); private: diff --git a/services/inputflinger/InputClassifierConverter.cpp b/services/inputflinger/InputClassifierConverter.cpp index f82c8ef1fd..fc8c7c39f9 100644 --- a/services/inputflinger/InputClassifierConverter.cpp +++ b/services/inputflinger/InputClassifierConverter.cpp @@ -358,6 +358,7 @@ common::V1_0::MotionEvent notifyMotionArgsToHalMotionEvent(const NotifyMotionArg event.displayId = args.displayId; event.downTime = args.downTime; event.eventTime = args.eventTime; + event.deviceTimestamp = 0; event.action = getAction(args.action & AMOTION_EVENT_ACTION_MASK); event.actionIndex = getActionIndex(args.action); event.actionButton = getActionButton(args.actionButton); @@ -375,7 +376,6 @@ common::V1_0::MotionEvent notifyMotionArgsToHalMotionEvent(const NotifyMotionArg event.pointerProperties = pointerProperties; event.pointerCoords = pointerCoords; - event.deviceTimestamp = args.deviceTimestamp; event.frames = convertVideoFrames(args.videoFrames); return event; diff --git a/services/inputflinger/InputDispatcher.cpp b/services/inputflinger/InputDispatcher.cpp index 1d8c365702..fb28d1b380 100644 --- a/services/inputflinger/InputDispatcher.cpp +++ b/services/inputflinger/InputDispatcher.cpp @@ -253,9 +253,17 @@ static void dumpRegion(std::string& dump, const Region& region) { } } -template<typename T, typename U> -static T getValueByKey(std::unordered_map<U, T>& map, U key) { - typename std::unordered_map<U, T>::const_iterator it = map.find(key); +/** + * Find the entry in std::unordered_map by key, and return it. + * If the entry is not found, return a default constructed entry. + * + * Useful when the entries are vectors, since an empty vector will be returned + * if the entry is not found. + * Also useful when the entries are sp<>. If an entry is not found, nullptr is returned. + */ +template <typename T, typename U> +static T getValueByKey(const std::unordered_map<U, T>& map, U key) { + auto it = map.find(key); return it != map.end() ? it->second : T{}; } @@ -3144,14 +3152,7 @@ void InputDispatcher::decrementPendingForegroundDispatches(EventEntry* entry) { std::vector<sp<InputWindowHandle>> InputDispatcher::getWindowHandlesLocked( int32_t displayId) const { - std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>>::const_iterator it = - mWindowHandlesByDisplay.find(displayId); - if(it != mWindowHandlesByDisplay.end()) { - return it->second; - } - - // Return an empty one if nothing found. - return std::vector<sp<InputWindowHandle>>(); + return getValueByKey(mWindowHandlesByDisplay, displayId); } sp<InputWindowHandle> InputDispatcher::getWindowHandleLocked( @@ -3193,6 +3194,63 @@ sp<InputChannel> InputDispatcher::getInputChannelLocked(const sp<IBinder>& token return mInputChannelsByToken.at(token); } +void InputDispatcher::updateWindowHandlesForDisplayLocked( + const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) { + if (inputWindowHandles.empty()) { + // Remove all handles on a display if there are no windows left. + mWindowHandlesByDisplay.erase(displayId); + return; + } + + // Since we compare the pointer of input window handles across window updates, we need + // to make sure the handle object for the same window stays unchanged across updates. + const std::vector<sp<InputWindowHandle>>& oldHandles = getWindowHandlesLocked(displayId); + std::unordered_map<sp<IBinder>, sp<InputWindowHandle>, IBinderHash> oldHandlesByTokens; + for (const sp<InputWindowHandle>& handle : oldHandles) { + oldHandlesByTokens[handle->getToken()] = handle; + } + + std::vector<sp<InputWindowHandle>> newHandles; + for (const sp<InputWindowHandle>& handle : inputWindowHandles) { + if (!handle->updateInfo()) { + // handle no longer valid + continue; + } + + const InputWindowInfo* info = handle->getInfo(); + if ((getInputChannelLocked(handle->getToken()) == nullptr && + info->portalToDisplayId == ADISPLAY_ID_NONE)) { + const bool noInputChannel = + info->inputFeatures & InputWindowInfo::INPUT_FEATURE_NO_INPUT_CHANNEL; + const bool canReceiveInput = + !(info->layoutParamsFlags & InputWindowInfo::FLAG_NOT_TOUCHABLE) || + !(info->layoutParamsFlags & InputWindowInfo::FLAG_NOT_FOCUSABLE); + if (canReceiveInput && !noInputChannel) { + ALOGE("Window handle %s has no registered input channel", + handle->getName().c_str()); + } + continue; + } + + if (info->displayId != displayId) { + ALOGE("Window %s updated by wrong display %d, should belong to display %d", + handle->getName().c_str(), displayId, info->displayId); + continue; + } + + if (oldHandlesByTokens.find(handle->getToken()) != oldHandlesByTokens.end()) { + const sp<InputWindowHandle> oldHandle = oldHandlesByTokens.at(handle->getToken()); + oldHandle->updateFrom(handle); + newHandles.push_back(oldHandle); + } else { + newHandles.push_back(handle); + } + } + + // Insert or replace + mWindowHandlesByDisplay[displayId] = newHandles; +} + /** * Called from InputManagerService, update window handle list by displayId that can receive input. * A window handle contains information about InputChannel, Touch Region, Types, Focused,... @@ -3212,73 +3270,19 @@ void InputDispatcher::setInputWindows(const std::vector<sp<InputWindowHandle>>& const std::vector<sp<InputWindowHandle>> oldWindowHandles = getWindowHandlesLocked(displayId); + updateWindowHandlesForDisplayLocked(inputWindowHandles, displayId); + sp<InputWindowHandle> newFocusedWindowHandle = nullptr; bool foundHoveredWindow = false; - - if (inputWindowHandles.empty()) { - // Remove all handles on a display if there are no windows left. - mWindowHandlesByDisplay.erase(displayId); - } else { - // Since we compare the pointer of input window handles across window updates, we need - // to make sure the handle object for the same window stays unchanged across updates. - const std::vector<sp<InputWindowHandle>>& oldHandles = - mWindowHandlesByDisplay[displayId]; - std::unordered_map<sp<IBinder>, sp<InputWindowHandle>, IBinderHash> oldHandlesByTokens; - for (const sp<InputWindowHandle>& handle : oldHandles) { - oldHandlesByTokens[handle->getToken()] = handle; - } - - std::vector<sp<InputWindowHandle>> newHandles; - for (const sp<InputWindowHandle>& handle : inputWindowHandles) { - if (!handle->updateInfo()) { - // handle no longer valid - continue; - } - const InputWindowInfo* info = handle->getInfo(); - - if ((getInputChannelLocked(handle->getToken()) == nullptr && - info->portalToDisplayId == ADISPLAY_ID_NONE)) { - const bool noInputChannel = - info->inputFeatures & InputWindowInfo::INPUT_FEATURE_NO_INPUT_CHANNEL; - const bool canReceiveInput = - !(info->layoutParamsFlags & InputWindowInfo::FLAG_NOT_TOUCHABLE) || - !(info->layoutParamsFlags & InputWindowInfo::FLAG_NOT_FOCUSABLE); - if (canReceiveInput && !noInputChannel) { - ALOGE("Window handle %s has no registered input channel", - handle->getName().c_str()); - } - continue; - } - - if (info->displayId != displayId) { - ALOGE("Window %s updated by wrong display %d, should belong to display %d", - handle->getName().c_str(), displayId, info->displayId); - continue; - } - - if (oldHandlesByTokens.find(handle->getToken()) != oldHandlesByTokens.end()) { - const sp<InputWindowHandle> oldHandle = - oldHandlesByTokens.at(handle->getToken()); - oldHandle->updateFrom(handle); - newHandles.push_back(oldHandle); - } else { - newHandles.push_back(handle); - } + for (const sp<InputWindowHandle>& windowHandle : getWindowHandlesLocked(displayId)) { + // Set newFocusedWindowHandle to the top most focused window instead of the last one + if (!newFocusedWindowHandle && windowHandle->getInfo()->hasFocus && + windowHandle->getInfo()->visible) { + newFocusedWindowHandle = windowHandle; } - - for (const sp<InputWindowHandle>& windowHandle : newHandles) { - // Set newFocusedWindowHandle to the top most focused window instead of the last one - if (!newFocusedWindowHandle && windowHandle->getInfo()->hasFocus - && windowHandle->getInfo()->visible) { - newFocusedWindowHandle = windowHandle; - } - if (windowHandle == mLastHoverWindowHandle) { - foundHoveredWindow = true; - } + if (windowHandle == mLastHoverWindowHandle) { + foundHoveredWindow = true; } - - // Insert or replace - mWindowHandlesByDisplay[displayId] = newHandles; } if (!foundHoveredWindow) { diff --git a/services/inputflinger/InputDispatcher.h b/services/inputflinger/InputDispatcher.h index 46dd9bd273..c30a8d6703 100644 --- a/services/inputflinger/InputDispatcher.h +++ b/services/inputflinger/InputDispatcher.h @@ -1055,6 +1055,13 @@ private: sp<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const REQUIRES(mLock); bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock); + /* + * Validate and update InputWindowHandles for a given display. + */ + void updateWindowHandlesForDisplayLocked( + const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) + REQUIRES(mLock); + // Focus tracking for keys, trackball, etc. std::unordered_map<int32_t, sp<InputWindowHandle>> mFocusedWindowHandlesByDisplay GUARDED_BY(mLock); diff --git a/services/inputflinger/InputListener.cpp b/services/inputflinger/InputListener.cpp index 0498e87732..de639772a8 100644 --- a/services/inputflinger/InputListener.cpp +++ b/services/inputflinger/InputListener.cpp @@ -92,10 +92,10 @@ NotifyMotionArgs::NotifyMotionArgs( uint32_t sequenceNum, nsecs_t eventTime, int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags, int32_t action, int32_t actionButton, int32_t flags, int32_t metaState, int32_t buttonState, MotionClassification classification, - int32_t edgeFlags, uint32_t deviceTimestamp, uint32_t pointerCount, - const PointerProperties* pointerProperties, const PointerCoords* pointerCoords, - float xPrecision, float yPrecision, float xCursorPosition, float yCursorPosition, - nsecs_t downTime, const std::vector<TouchVideoFrame>& videoFrames) + int32_t edgeFlags, uint32_t pointerCount, const PointerProperties* pointerProperties, + const PointerCoords* pointerCoords, float xPrecision, float yPrecision, + float xCursorPosition, float yCursorPosition, nsecs_t downTime, + const std::vector<TouchVideoFrame>& videoFrames) : NotifyArgs(sequenceNum, eventTime), deviceId(deviceId), source(source), @@ -108,7 +108,6 @@ NotifyMotionArgs::NotifyMotionArgs( buttonState(buttonState), classification(classification), edgeFlags(edgeFlags), - deviceTimestamp(deviceTimestamp), pointerCount(pointerCount), xPrecision(xPrecision), yPrecision(yPrecision), @@ -135,7 +134,6 @@ NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other) buttonState(other.buttonState), classification(other.classification), edgeFlags(other.edgeFlags), - deviceTimestamp(other.deviceTimestamp), pointerCount(other.pointerCount), xPrecision(other.xPrecision), yPrecision(other.yPrecision), @@ -159,7 +157,7 @@ bool NotifyMotionArgs::operator==(const NotifyMotionArgs& rhs) const { policyFlags == rhs.policyFlags && action == rhs.action && actionButton == rhs.actionButton && flags == rhs.flags && metaState == rhs.metaState && buttonState == rhs.buttonState && classification == rhs.classification && - edgeFlags == rhs.edgeFlags && deviceTimestamp == rhs.deviceTimestamp && + edgeFlags == rhs.edgeFlags && pointerCount == rhs.pointerCount // PointerProperties and PointerCoords are compared separately below && xPrecision == rhs.xPrecision && yPrecision == rhs.yPrecision && diff --git a/services/inputflinger/InputReader.cpp b/services/inputflinger/InputReader.cpp index 9e5990964c..3e236a93ae 100644 --- a/services/inputflinger/InputReader.cpp +++ b/services/inputflinger/InputReader.cpp @@ -260,12 +260,17 @@ static void synthesizeButtonKeys(InputReaderContext* context, int32_t action, // --- InputReader --- -InputReader::InputReader(const sp<EventHubInterface>& eventHub, - const sp<InputReaderPolicyInterface>& policy, - const sp<InputListenerInterface>& listener) : - mContext(this), mEventHub(eventHub), mPolicy(policy), - mNextSequenceNum(1), mGlobalMetaState(0), mGeneration(1), - mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX), +InputReader::InputReader(std::shared_ptr<EventHubInterface> eventHub, + const sp<InputReaderPolicyInterface>& policy, + const sp<InputListenerInterface>& listener) + : mContext(this), + mEventHub(eventHub), + mPolicy(policy), + mNextSequenceNum(1), + mGlobalMetaState(0), + mGeneration(1), + mDisableVirtualKeysTimeout(LLONG_MIN), + mNextTimeout(LLONG_MAX), mConfigurationChangesToRefresh(0) { mQueuedListener = new QueuedInputListener(listener); @@ -559,7 +564,8 @@ void InputReader::refreshConfigurationLocked(uint32_t changes) { mEventHub->setExcludedDevices(mConfig.excludedDeviceNames); if (changes) { - ALOGI("Reconfiguring input devices. changes=0x%08x", changes); + ALOGI("Reconfiguring input devices, changes=%s", + InputReaderConfiguration::changesToString(changes).c_str()); nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); if (changes & InputReaderConfiguration::CHANGE_MUST_REOPEN) { @@ -1093,8 +1099,8 @@ void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config } if (!changes || (changes & InputReaderConfiguration::CHANGE_ENABLED_STATE)) { - ssize_t index = config->disabledDevices.indexOf(mId); - bool enabled = index < 0; + auto it = config->disabledDevices.find(mId); + bool enabled = it == config->disabledDevices.end(); setEnabled(enabled, when); } @@ -1731,10 +1737,12 @@ void SingleTouchMotionAccumulator::process(const RawEvent* rawEvent) { // --- MultiTouchMotionAccumulator --- -MultiTouchMotionAccumulator::MultiTouchMotionAccumulator() : - mCurrentSlot(-1), mSlots(nullptr), mSlotCount(0), mUsingSlotsProtocol(false), - mHaveStylus(false), mDeviceTimestamp(0) { -} +MultiTouchMotionAccumulator::MultiTouchMotionAccumulator() + : mCurrentSlot(-1), + mSlots(nullptr), + mSlotCount(0), + mUsingSlotsProtocol(false), + mHaveStylus(false) {} MultiTouchMotionAccumulator::~MultiTouchMotionAccumulator() { delete[] mSlots; @@ -1774,7 +1782,6 @@ void MultiTouchMotionAccumulator::reset(InputDevice* device) { } else { clearSlots(-1); } - mDeviceTimestamp = 0; } void MultiTouchMotionAccumulator::clearSlots(int32_t initialSlot) { @@ -1868,8 +1875,6 @@ void MultiTouchMotionAccumulator::process(const RawEvent* rawEvent) { } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_MT_REPORT) { // MultiTouch Sync: The driver has returned all data for *one* of the pointers. mCurrentSlot += 1; - } else if (rawEvent->type == EV_MSC && rawEvent->code == MSC_TIMESTAMP) { - mDeviceTimestamp = rawEvent->value; } } @@ -2849,8 +2854,7 @@ void CursorInputMapper::sync(nsecs_t when) { mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_BUTTON_RELEASE, actionButton, 0, metaState, buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &pointerProperties, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, yCursorPosition, downTime, /* videoFrames */ {}); @@ -2861,8 +2865,7 @@ void CursorInputMapper::sync(nsecs_t when) { NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, motionEventAction, 0, 0, metaState, currentButtonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, yCursorPosition, downTime, /* videoFrames */ {}); getListener()->notifyMotion(&args); @@ -2876,8 +2879,7 @@ void CursorInputMapper::sync(nsecs_t when) { mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_BUTTON_PRESS, actionButton, 0, metaState, buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &pointerProperties, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, yCursorPosition, downTime, /* videoFrames */ {}); @@ -2893,11 +2895,9 @@ void CursorInputMapper::sync(nsecs_t when) { NotifyMotionArgs hoverArgs(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, currentButtonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &pointerProperties, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, - yCursorPosition, downTime, - /* videoFrames */ {}); + yCursorPosition, downTime, /* videoFrames */ {}); getListener()->notifyMotion(&hoverArgs); } @@ -2910,11 +2910,9 @@ void CursorInputMapper::sync(nsecs_t when) { mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, currentButtonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &pointerProperties, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, - yCursorPosition, downTime, - /* videoFrames */ {}); + yCursorPosition, downTime, /* videoFrames */ {}); getListener()->notifyMotion(&scrollArgs); } } @@ -3057,9 +3055,8 @@ void RotaryEncoderInputMapper::sync(nsecs_t when) { NotifyMotionArgs scrollArgs(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, /* buttonState */ 0, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords, - 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, + &pointerCoords, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION, 0, /* videoFrames */ {}); getListener()->notifyMotion(&scrollArgs); } @@ -4781,7 +4778,6 @@ void TouchInputMapper::abortTouches(nsecs_t when, uint32_t policyFlags) { int32_t buttonState = mCurrentCookedState.buttonState; dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mCurrentCookedState.deviceTimestamp, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, @@ -4804,7 +4800,6 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mCurrentCookedState.deviceTimestamp, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, @@ -4839,7 +4834,6 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_UP, 0, 0, metaState, buttonState, 0, - mCurrentCookedState.deviceTimestamp, mLastCookedState.cookedPointerData.pointerProperties, mLastCookedState.cookedPointerData.pointerCoords, mLastCookedState.cookedPointerData.idToIndex, @@ -4854,7 +4848,6 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value); dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, 0, - mCurrentCookedState.deviceTimestamp, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, @@ -4873,7 +4866,6 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_DOWN, 0, 0, metaState, buttonState, 0, - mCurrentCookedState.deviceTimestamp, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, @@ -4889,7 +4881,6 @@ void TouchInputMapper::dispatchHoverExit(nsecs_t when, uint32_t policyFlags) { int32_t metaState = getContext()->getGlobalMetaState(); dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, metaState, mLastCookedState.buttonState, 0, - mLastCookedState.deviceTimestamp, mLastCookedState.cookedPointerData.pointerProperties, mLastCookedState.cookedPointerData.pointerCoords, mLastCookedState.cookedPointerData.idToIndex, @@ -4906,7 +4897,6 @@ void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFl if (!mSentHoverEnter) { dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_ENTER, 0, 0, metaState, mCurrentRawState.buttonState, 0, - mCurrentCookedState.deviceTimestamp, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, @@ -4918,7 +4908,6 @@ void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFl dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, mCurrentRawState.buttonState, 0, - mCurrentCookedState.deviceTimestamp, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, @@ -4938,7 +4927,6 @@ void TouchInputMapper::dispatchButtonRelease(nsecs_t when, uint32_t policyFlags) dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_BUTTON_RELEASE, actionButton, 0, metaState, buttonState, 0, - mCurrentCookedState.deviceTimestamp, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, idBits, -1, @@ -4956,7 +4944,6 @@ void TouchInputMapper::dispatchButtonPress(nsecs_t when, uint32_t policyFlags) { buttonState |= actionButton; dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_BUTTON_PRESS, actionButton, 0, metaState, buttonState, 0, - mCurrentCookedState.deviceTimestamp, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, idBits, -1, @@ -4975,8 +4962,6 @@ void TouchInputMapper::cookPointerData() { uint32_t currentPointerCount = mCurrentRawState.rawPointerData.pointerCount; mCurrentCookedState.cookedPointerData.clear(); - mCurrentCookedState.deviceTimestamp = - mCurrentRawState.deviceTimestamp; mCurrentCookedState.cookedPointerData.pointerCount = currentPointerCount; mCurrentCookedState.cookedPointerData.hoveringIdBits = mCurrentRawState.rawPointerData.hoveringIdBits; @@ -5368,13 +5353,11 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag BitSet32 dispatchedGestureIdBits(mPointerGesture.lastGestureIdBits); if (!dispatchedGestureIdBits.isEmpty()) { if (cancelPreviousGesture) { - dispatchMotion(when, policyFlags, mSource, - AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, buttonState, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, - mPointerGesture.lastGestureProperties, - mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, - dispatchedGestureIdBits, -1, 0, - 0, mPointerGesture.downTime); + dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, + buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.lastGestureProperties, mPointerGesture.lastGestureCoords, + mPointerGesture.lastGestureIdToIndex, dispatchedGestureIdBits, -1, 0, 0, + mPointerGesture.downTime); dispatchedGestureIdBits.clear(); } else { @@ -5391,7 +5374,6 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_UP, 0, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, mPointerGesture.lastGestureProperties, mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, dispatchedGestureIdBits, id, @@ -5404,13 +5386,12 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag // Send motion events for all pointers that moved. if (moveNeeded) { - dispatchMotion(when, policyFlags, mSource, - AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, - mPointerGesture.currentGestureProperties, - mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, - dispatchedGestureIdBits, -1, - 0, 0, mPointerGesture.downTime); + dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, + buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.currentGestureProperties, + mPointerGesture.currentGestureCoords, + mPointerGesture.currentGestureIdToIndex, dispatchedGestureIdBits, -1, 0, 0, + mPointerGesture.downTime); } // Send motion events for all pointers that went down. @@ -5427,7 +5408,6 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_DOWN, 0, 0, metaState, buttonState, 0, - /* deviceTimestamp */ 0, mPointerGesture.currentGestureProperties, mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, dispatchedGestureIdBits, id, @@ -5437,13 +5417,12 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag // Send motion events for hover. if (mPointerGesture.currentGestureMode == PointerGesture::HOVER) { - dispatchMotion(when, policyFlags, mSource, - AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, - metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, - mPointerGesture.currentGestureProperties, - mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, - mPointerGesture.currentGestureIdBits, -1, - 0, 0, mPointerGesture.downTime); + dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, + buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.currentGestureProperties, + mPointerGesture.currentGestureCoords, + mPointerGesture.currentGestureIdToIndex, + mPointerGesture.currentGestureIdBits, -1, 0, 0, mPointerGesture.downTime); } else if (dispatchedGestureIdBits.isEmpty() && !mPointerGesture.lastGestureIdBits.isEmpty()) { // Synthesize a hover move event after all pointers go up to indicate that @@ -5467,9 +5446,8 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords, 0, 0, - x, y, mPointerGesture.downTime, /* videoFrames */ {}); + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, + 0, 0, x, y, mPointerGesture.downTime, /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -5496,13 +5474,11 @@ void TouchInputMapper::abortPointerGestures(nsecs_t when, uint32_t policyFlags) if (!mPointerGesture.lastGestureIdBits.isEmpty()) { int32_t metaState = getContext()->getGlobalMetaState(); int32_t buttonState = mCurrentRawState.buttonState; - dispatchMotion(when, policyFlags, mSource, - AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, buttonState, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, - mPointerGesture.lastGestureProperties, - mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, - mPointerGesture.lastGestureIdBits, -1, - 0, 0, mPointerGesture.downTime); + dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, + buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.lastGestureProperties, mPointerGesture.lastGestureCoords, + mPointerGesture.lastGestureIdToIndex, mPointerGesture.lastGestureIdBits, -1, + 0, 0, mPointerGesture.downTime); } // Reset the current pointer gesture. @@ -6395,10 +6371,10 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_UP, 0, 0, metaState, mLastRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, 1, - &mPointerSimple.lastProperties, &mPointerSimple.lastCoords, - mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, - yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.lastProperties, + &mPointerSimple.lastCoords, mOrientedXPrecision, mOrientedYPrecision, + xCursorPosition, yCursorPosition, mPointerSimple.downTime, + /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -6409,10 +6385,10 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, metaState, mLastRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, 1, - &mPointerSimple.lastProperties, &mPointerSimple.lastCoords, - mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, - yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.lastProperties, + &mPointerSimple.lastCoords, mOrientedXPrecision, mOrientedYPrecision, + xCursorPosition, yCursorPosition, mPointerSimple.downTime, + /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -6425,11 +6401,10 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_DOWN, 0, 0, metaState, mCurrentRawState.buttonState, - MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &mPointerSimple.currentProperties, - &mPointerSimple.currentCoords, mOrientedXPrecision, - mOrientedYPrecision, xCursorPosition, yCursorPosition, - mPointerSimple.downTime, /* videoFrames */ {}); + MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, + mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, + yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -6437,10 +6412,10 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, mCurrentRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, 1, - &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, - mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, - yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, + &mPointerSimple.currentCoords, mOrientedXPrecision, + mOrientedYPrecision, xCursorPosition, yCursorPosition, + mPointerSimple.downTime, /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -6452,11 +6427,10 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_ENTER, 0, 0, metaState, mCurrentRawState.buttonState, - MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &mPointerSimple.currentProperties, - &mPointerSimple.currentCoords, mOrientedXPrecision, - mOrientedYPrecision, xCursorPosition, yCursorPosition, - mPointerSimple.downTime, /* videoFrames */ {}); + MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, + mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, + yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -6464,10 +6438,10 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, mCurrentRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, 1, - &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, - mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, - yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, + &mPointerSimple.currentCoords, mOrientedXPrecision, + mOrientedYPrecision, xCursorPosition, yCursorPosition, + mPointerSimple.downTime, /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -6486,10 +6460,10 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, mCurrentRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, 1, - &mPointerSimple.currentProperties, &pointerCoords, - mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, - yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, + &pointerCoords, mOrientedXPrecision, mOrientedYPrecision, + xCursorPosition, yCursorPosition, mPointerSimple.downTime, + /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -6510,11 +6484,12 @@ void TouchInputMapper::abortPointerSimple(nsecs_t when, uint32_t policyFlags) { } void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source, - int32_t action, int32_t actionButton, int32_t flags, - int32_t metaState, int32_t buttonState, int32_t edgeFlags, uint32_t deviceTimestamp, - const PointerProperties* properties, const PointerCoords* coords, - const uint32_t* idToIndex, BitSet32 idBits, int32_t changedId, - float xPrecision, float yPrecision, nsecs_t downTime) { + int32_t action, int32_t actionButton, int32_t flags, + int32_t metaState, int32_t buttonState, int32_t edgeFlags, + const PointerProperties* properties, + const PointerCoords* coords, const uint32_t* idToIndex, + BitSet32 idBits, int32_t changedId, float xPrecision, + float yPrecision, nsecs_t downTime) { PointerCoords pointerCoords[MAX_POINTERS]; PointerProperties pointerProperties[MAX_POINTERS]; uint32_t pointerCount = 0; @@ -6558,9 +6533,9 @@ void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32 [this](TouchVideoFrame& frame) { frame.rotate(this->mSurfaceOrientation); }); NotifyMotionArgs args(mContext->getNextSequenceNum(), when, deviceId, source, displayId, policyFlags, action, actionButton, flags, metaState, buttonState, - MotionClassification::NONE, edgeFlags, deviceTimestamp, pointerCount, - pointerProperties, pointerCoords, xPrecision, yPrecision, xCursorPosition, - yCursorPosition, downTime, std::move(frames)); + MotionClassification::NONE, edgeFlags, pointerCount, pointerProperties, + pointerCoords, xPrecision, yPrecision, xCursorPosition, yCursorPosition, + downTime, std::move(frames)); getListener()->notifyMotion(&args); } @@ -7043,7 +7018,6 @@ void MultiTouchInputMapper::syncTouch(nsecs_t when, RawState* outState) { outCount += 1; } - outState->deviceTimestamp = mMultiTouchMotionAccumulator.getDeviceTimestamp(); outState->rawPointerData.pointerCount = outCount; mPointerIdBits = newPointerIdBits; @@ -7484,8 +7458,8 @@ void JoystickInputMapper::sync(nsecs_t when, bool force) { NotifyMotionArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, ADISPLAY_ID_NONE, policyFlags, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, - MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, - /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords, 0, 0, + MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &pointerProperties, &pointerCoords, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION, 0, /* videoFrames */ {}); getListener()->notifyMotion(&args); diff --git a/services/inputflinger/InputReader.h b/services/inputflinger/InputReader.h index 9777779e7d..11ef9347dc 100644 --- a/services/inputflinger/InputReader.h +++ b/services/inputflinger/InputReader.h @@ -114,9 +114,9 @@ public: */ class InputReader : public InputReaderInterface { public: - InputReader(const sp<EventHubInterface>& eventHub, - const sp<InputReaderPolicyInterface>& policy, - const sp<InputListenerInterface>& listener); + InputReader(std::shared_ptr<EventHubInterface> eventHub, + const sp<InputReaderPolicyInterface>& policy, + const sp<InputListenerInterface>& listener); virtual ~InputReader(); virtual void dump(std::string& dump); @@ -181,7 +181,10 @@ private: Condition mReaderIsAliveCondition; - sp<EventHubInterface> mEventHub; + // This could be unique_ptr, but due to the way InputReader tests are written, + // it is made shared_ptr here. In the tests, an EventHub reference is retained by the test + // in parallel to passing it to the InputReader. + std::shared_ptr<EventHubInterface> mEventHub; sp<InputReaderPolicyInterface> mPolicy; sp<QueuedInputListener> mQueuedListener; @@ -717,7 +720,6 @@ public: inline size_t getSlotCount() const { return mSlotCount; } inline const Slot* getSlot(size_t index) const { return &mSlots[index]; } - inline uint32_t getDeviceTimestamp() const { return mDeviceTimestamp; } private: int32_t mCurrentSlot; @@ -725,7 +727,6 @@ private: size_t mSlotCount; bool mUsingSlotsProtocol; bool mHaveStylus; - uint32_t mDeviceTimestamp; void clearSlots(int32_t initialSlot); }; @@ -1174,7 +1175,6 @@ protected: struct RawState { nsecs_t when; - uint32_t deviceTimestamp; // Raw pointer sample data. RawPointerData rawPointerData; @@ -1187,7 +1187,6 @@ protected: void copyFrom(const RawState& other) { when = other.when; - deviceTimestamp = other.deviceTimestamp; rawPointerData.copyFrom(other.rawPointerData); buttonState = other.buttonState; rawVScroll = other.rawVScroll; @@ -1196,7 +1195,6 @@ protected: void clear() { when = 0; - deviceTimestamp = 0; rawPointerData.clear(); buttonState = 0; rawVScroll = 0; @@ -1205,7 +1203,6 @@ protected: }; struct CookedState { - uint32_t deviceTimestamp; // Cooked pointer sample data. CookedPointerData cookedPointerData; @@ -1217,7 +1214,6 @@ protected: int32_t buttonState; void copyFrom(const CookedState& other) { - deviceTimestamp = other.deviceTimestamp; cookedPointerData.copyFrom(other.cookedPointerData); fingerIdBits = other.fingerIdBits; stylusIdBits = other.stylusIdBits; @@ -1226,7 +1222,6 @@ protected: } void clear() { - deviceTimestamp = 0; cookedPointerData.clear(); fingerIdBits.clear(); stylusIdBits.clear(); @@ -1634,7 +1629,6 @@ private: void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source, int32_t action, int32_t actionButton, int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags, - uint32_t deviceTimestamp, const PointerProperties* properties, const PointerCoords* coords, const uint32_t* idToIndex, BitSet32 idBits, int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime); diff --git a/services/inputflinger/InputReaderBase.cpp b/services/inputflinger/InputReaderBase.cpp index f48a64551e..bc53cf52cc 100644 --- a/services/inputflinger/InputReaderBase.cpp +++ b/services/inputflinger/InputReaderBase.cpp @@ -49,6 +49,44 @@ bool InputReaderThread::threadLoop() { // --- InputReaderConfiguration --- +std::string InputReaderConfiguration::changesToString(uint32_t changes) { + if (changes == 0) { + return "<none>"; + } + std::string result; + if (changes & CHANGE_POINTER_SPEED) { + result += "POINTER_SPEED | "; + } + if (changes & CHANGE_POINTER_GESTURE_ENABLEMENT) { + result += "POINTER_GESTURE_ENABLEMENT | "; + } + if (changes & CHANGE_DISPLAY_INFO) { + result += "DISPLAY_INFO | "; + } + if (changes & CHANGE_SHOW_TOUCHES) { + result += "SHOW_TOUCHES | "; + } + if (changes & CHANGE_KEYBOARD_LAYOUTS) { + result += "KEYBOARD_LAYOUTS | "; + } + if (changes & CHANGE_DEVICE_ALIAS) { + result += "DEVICE_ALIAS | "; + } + if (changes & CHANGE_TOUCH_AFFINE_TRANSFORMATION) { + result += "TOUCH_AFFINE_TRANSFORMATION | "; + } + if (changes & CHANGE_EXTERNAL_STYLUS_PRESENCE) { + result += "EXTERNAL_STYLUS_PRESENCE | "; + } + if (changes & CHANGE_ENABLED_STATE) { + result += "ENABLED_STATE | "; + } + if (changes & CHANGE_MUST_REOPEN) { + result += "MUST_REOPEN | "; + } + return result; +} + std::optional<DisplayViewport> InputReaderConfiguration::getDisplayViewportByUniqueId( const std::string& uniqueDisplayId) const { if (uniqueDisplayId.empty()) { diff --git a/services/inputflinger/InputReaderFactory.cpp b/services/inputflinger/InputReaderFactory.cpp index 3534f6b760..072499b9cd 100644 --- a/services/inputflinger/InputReaderFactory.cpp +++ b/services/inputflinger/InputReaderFactory.cpp @@ -22,7 +22,7 @@ namespace android { sp<InputReaderInterface> createInputReader( const sp<InputReaderPolicyInterface>& policy, const sp<InputListenerInterface>& listener) { - return new InputReader(new EventHub(), policy, listener); + return new InputReader(std::make_unique<EventHub>(), policy, listener); } } // namespace android
\ No newline at end of file diff --git a/services/inputflinger/include/InputListener.h b/services/inputflinger/include/InputListener.h index 57c894bf8b..0dcd2f9c38 100644 --- a/services/inputflinger/include/InputListener.h +++ b/services/inputflinger/include/InputListener.h @@ -107,13 +107,7 @@ struct NotifyMotionArgs : public NotifyArgs { */ MotionClassification classification; int32_t edgeFlags; - /** - * A timestamp in the input device's time base, not the platform's. - * The units are microseconds since the last reset. - * This can only be compared to other device timestamps from the same device. - * This value will overflow after a little over an hour. - */ - uint32_t deviceTimestamp; + uint32_t pointerCount; PointerProperties pointerProperties[MAX_POINTERS]; PointerCoords pointerCoords[MAX_POINTERS]; @@ -134,8 +128,7 @@ struct NotifyMotionArgs : public NotifyArgs { NotifyMotionArgs(uint32_t sequenceNum, nsecs_t eventTime, int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags, int32_t action, int32_t actionButton, int32_t flags, int32_t metaState, int32_t buttonState, - MotionClassification classification, int32_t edgeFlags, - uint32_t deviceTimestamp, uint32_t pointerCount, + MotionClassification classification, int32_t edgeFlags, uint32_t pointerCount, const PointerProperties* pointerProperties, const PointerCoords* pointerCoords, float xPrecision, float yPrecision, float xCursorPosition, float yCursorPosition, nsecs_t downTime, diff --git a/services/inputflinger/include/InputReaderBase.h b/services/inputflinger/include/InputReaderBase.h index 8ad5dd0785..5d576b94f3 100644 --- a/services/inputflinger/include/InputReaderBase.h +++ b/services/inputflinger/include/InputReaderBase.h @@ -24,14 +24,13 @@ #include <input/DisplayViewport.h> #include <input/VelocityControl.h> #include <input/VelocityTracker.h> -#include <utils/KeyedVector.h> #include <utils/Thread.h> #include <utils/RefBase.h> -#include <utils/SortedVector.h> -#include <optional> #include <stddef.h> #include <unistd.h> +#include <optional> +#include <set> #include <unordered_map> #include <vector> @@ -250,7 +249,7 @@ struct InputReaderConfiguration { bool pointerCapture; // The set of currently disabled input devices. - SortedVector<int32_t> disabledDevices; + std::set<int32_t> disabledDevices; InputReaderConfiguration() : virtualKeyQuietTime(0), @@ -270,6 +269,8 @@ struct InputReaderConfiguration { pointerGestureZoomSpeedRatio(0.3f), showTouches(false), pointerCapture(false) { } + static std::string changesToString(uint32_t changes); + std::optional<DisplayViewport> getDisplayViewportByType(ViewportType type) const; std::optional<DisplayViewport> getDisplayViewportByUniqueId(const std::string& uniqueDisplayId) const; diff --git a/services/inputflinger/tests/InputClassifierConverter_test.cpp b/services/inputflinger/tests/InputClassifierConverter_test.cpp index ba1c7c9284..f58b6281df 100644 --- a/services/inputflinger/tests/InputClassifierConverter_test.cpp +++ b/services/inputflinger/tests/InputClassifierConverter_test.cpp @@ -42,9 +42,9 @@ static NotifyMotionArgs generateBasicMotionArgs() { AINPUT_SOURCE_ANY, ADISPLAY_ID_DEFAULT, 4 /*policyFlags*/, AMOTION_EVENT_ACTION_DOWN, 0 /*actionButton*/, 0 /*flags*/, AMETA_NONE, 0 /*buttonState*/, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 5 /*deviceTimestamp*/, - 1 /*pointerCount*/, &properties, &coords, 0 /*xPrecision*/, - 0 /*yPrecision*/, AMOTION_EVENT_INVALID_CURSOR_POSITION, + AMOTION_EVENT_EDGE_FLAG_NONE, 1 /*pointerCount*/, &properties, + &coords, 0 /*xPrecision*/, 0 /*yPrecision*/, + AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION, downTime, {} /*videoFrames*/); return motionArgs; diff --git a/services/inputflinger/tests/InputClassifier_test.cpp b/services/inputflinger/tests/InputClassifier_test.cpp index 9bc4282d9c..40086ef708 100644 --- a/services/inputflinger/tests/InputClassifier_test.cpp +++ b/services/inputflinger/tests/InputClassifier_test.cpp @@ -42,9 +42,9 @@ static NotifyMotionArgs generateBasicMotionArgs() { AINPUT_SOURCE_ANY, ADISPLAY_ID_DEFAULT, 4 /*policyFlags*/, AMOTION_EVENT_ACTION_DOWN, 0 /*actionButton*/, 0 /*flags*/, AMETA_NONE, 0 /*buttonState*/, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 5 /*deviceTimestamp*/, - 1 /*pointerCount*/, &properties, &coords, 0 /*xPrecision*/, - 0 /*yPrecision*/, AMOTION_EVENT_INVALID_CURSOR_POSITION, + AMOTION_EVENT_EDGE_FLAG_NONE, 1 /*pointerCount*/, &properties, + &coords, 0 /*xPrecision*/, 0 /*yPrecision*/, + AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION, downTime, {} /*videoFrames*/); return motionArgs; diff --git a/services/inputflinger/tests/InputDispatcher_test.cpp b/services/inputflinger/tests/InputDispatcher_test.cpp index c28a6214d6..a86dcbc552 100644 --- a/services/inputflinger/tests/InputDispatcher_test.cpp +++ b/services/inputflinger/tests/InputDispatcher_test.cpp @@ -608,8 +608,8 @@ static NotifyMotionArgs generateMotionArgs(int32_t action, int32_t source, int32 NotifyMotionArgs args(/* sequenceNum */ 0, currentTime, DEVICE_ID, source, displayId, POLICY_FLAG_PASS_TO_USER, action, /* actionButton */ 0, /* flags */ 0, AMETA_NONE, /* buttonState */ 0, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, /* deviceTimestamp */ 0, 1, - pointerProperties, pointerCoords, /* xPrecision */ 0, /* yPrecision */ 0, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, pointerProperties, pointerCoords, + /* xPrecision */ 0, /* yPrecision */ 0, AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION, currentTime, /* videoFrames */ {}); diff --git a/services/inputflinger/tests/InputReader_test.cpp b/services/inputflinger/tests/InputReader_test.cpp index d35302885d..d95ac96124 100644 --- a/services/inputflinger/tests/InputReader_test.cpp +++ b/services/inputflinger/tests/InputReader_test.cpp @@ -202,21 +202,9 @@ public: mConfig.portAssociations.insert({inputPort, displayPort}); } - void addDisabledDevice(int32_t deviceId) { - ssize_t index = mConfig.disabledDevices.indexOf(deviceId); - bool currentlyEnabled = index < 0; - if (currentlyEnabled) { - mConfig.disabledDevices.add(deviceId); - } - } + void addDisabledDevice(int32_t deviceId) { mConfig.disabledDevices.insert(deviceId); } - void removeDisabledDevice(int32_t deviceId) { - ssize_t index = mConfig.disabledDevices.indexOf(deviceId); - bool currentlyEnabled = index < 0; - if (!currentlyEnabled) { - mConfig.disabledDevices.remove(deviceId); - } - } + void removeDisabledDevice(int32_t deviceId) { mConfig.disabledDevices.erase(deviceId); } void setPointerController(int32_t deviceId, const sp<FakePointerController>& controller) { mPointerControllers.add(deviceId, controller); @@ -337,14 +325,13 @@ class FakeEventHub : public EventHubInterface { List<RawEvent> mEvents; std::unordered_map<int32_t /*deviceId*/, std::vector<TouchVideoFrame>> mVideoFrames; -protected: +public: virtual ~FakeEventHub() { for (size_t i = 0; i < mDevices.size(); i++) { delete mDevices.valueAt(i); } } -public: FakeEventHub() { } void addDevice(int32_t deviceId, const std::string& name, uint32_t classes) { @@ -772,7 +759,7 @@ private: // --- FakeInputReaderContext --- class FakeInputReaderContext : public InputReaderContext { - sp<EventHubInterface> mEventHub; + std::shared_ptr<EventHubInterface> mEventHub; sp<InputReaderPolicyInterface> mPolicy; sp<InputListenerInterface> mListener; int32_t mGlobalMetaState; @@ -781,12 +768,14 @@ class FakeInputReaderContext : public InputReaderContext { uint32_t mNextSequenceNum; public: - FakeInputReaderContext(const sp<EventHubInterface>& eventHub, - const sp<InputReaderPolicyInterface>& policy, - const sp<InputListenerInterface>& listener) : - mEventHub(eventHub), mPolicy(policy), mListener(listener), - mGlobalMetaState(0), mNextSequenceNum(1) { - } + FakeInputReaderContext(std::shared_ptr<EventHubInterface> eventHub, + const sp<InputReaderPolicyInterface>& policy, + const sp<InputListenerInterface>& listener) + : mEventHub(eventHub), + mPolicy(policy), + mListener(listener), + mGlobalMetaState(0), + mNextSequenceNum(1) {} virtual ~FakeInputReaderContext() { } @@ -1011,12 +1000,10 @@ class InstrumentedInputReader : public InputReader { InputDevice* mNextDevice; public: - InstrumentedInputReader(const sp<EventHubInterface>& eventHub, - const sp<InputReaderPolicyInterface>& policy, - const sp<InputListenerInterface>& listener) : - InputReader(eventHub, policy, listener), - mNextDevice(nullptr) { - } + InstrumentedInputReader(std::shared_ptr<EventHubInterface> eventHub, + const sp<InputReaderPolicyInterface>& policy, + const sp<InputListenerInterface>& listener) + : InputReader(eventHub, policy, listener), mNextDevice(nullptr) {} virtual ~InstrumentedInputReader() { if (mNextDevice) { @@ -1244,11 +1231,11 @@ class InputReaderTest : public testing::Test { protected: sp<TestInputListener> mFakeListener; sp<FakeInputReaderPolicy> mFakePolicy; - sp<FakeEventHub> mFakeEventHub; + std::shared_ptr<FakeEventHub> mFakeEventHub; sp<InstrumentedInputReader> mReader; virtual void SetUp() { - mFakeEventHub = new FakeEventHub(); + mFakeEventHub = std::make_unique<FakeEventHub>(); mFakePolicy = new FakeInputReaderPolicy(); mFakeListener = new TestInputListener(); @@ -1260,7 +1247,6 @@ protected: mFakeListener.clear(); mFakePolicy.clear(); - mFakeEventHub.clear(); } void addDevice(int32_t deviceId, const std::string& name, uint32_t classes, @@ -1587,7 +1573,7 @@ protected: static const int32_t DEVICE_CONTROLLER_NUMBER; static const uint32_t DEVICE_CLASSES; - sp<FakeEventHub> mFakeEventHub; + std::shared_ptr<FakeEventHub> mFakeEventHub; sp<FakeInputReaderPolicy> mFakePolicy; sp<TestInputListener> mFakeListener; FakeInputReaderContext* mFakeContext; @@ -1595,7 +1581,7 @@ protected: InputDevice* mDevice; virtual void SetUp() { - mFakeEventHub = new FakeEventHub(); + mFakeEventHub = std::make_unique<FakeEventHub>(); mFakePolicy = new FakeInputReaderPolicy(); mFakeListener = new TestInputListener(); mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeListener); @@ -1613,7 +1599,6 @@ protected: delete mFakeContext; mFakeListener.clear(); mFakePolicy.clear(); - mFakeEventHub.clear(); } }; @@ -1782,14 +1767,14 @@ protected: static const int32_t DEVICE_CONTROLLER_NUMBER; static const uint32_t DEVICE_CLASSES; - sp<FakeEventHub> mFakeEventHub; + std::shared_ptr<FakeEventHub> mFakeEventHub; sp<FakeInputReaderPolicy> mFakePolicy; sp<TestInputListener> mFakeListener; FakeInputReaderContext* mFakeContext; InputDevice* mDevice; virtual void SetUp() { - mFakeEventHub = new FakeEventHub(); + mFakeEventHub = std::make_unique<FakeEventHub>(); mFakePolicy = new FakeInputReaderPolicy(); mFakeListener = new TestInputListener(); mFakeContext = new FakeInputReaderContext(mFakeEventHub, mFakePolicy, mFakeListener); @@ -1807,7 +1792,6 @@ protected: delete mFakeContext; mFakeListener.clear(); mFakePolicy.clear(); - mFakeEventHub.clear(); } void addConfigurationProperty(const char* key, const char* value) { @@ -4688,7 +4672,6 @@ protected: void processSlot(MultiTouchInputMapper* mapper, int32_t slot); void processToolType(MultiTouchInputMapper* mapper, int32_t toolType); void processKey(MultiTouchInputMapper* mapper, int32_t code, int32_t value); - void processTimestamp(MultiTouchInputMapper* mapper, uint32_t value); void processMTSync(MultiTouchInputMapper* mapper); void processSync(MultiTouchInputMapper* mapper); }; @@ -4804,10 +4787,6 @@ void MultiTouchInputMapperTest::processKey( process(mapper, ARBITRARY_TIME, EV_KEY, code, value); } -void MultiTouchInputMapperTest::processTimestamp(MultiTouchInputMapper* mapper, uint32_t value) { - process(mapper, ARBITRARY_TIME, EV_MSC, MSC_TIMESTAMP, value); -} - void MultiTouchInputMapperTest::processMTSync(MultiTouchInputMapper* mapper) { process(mapper, ARBITRARY_TIME, EV_SYN, SYN_MT_REPORT, 0); } @@ -6190,64 +6169,6 @@ TEST_F(MultiTouchInputMapperTest, Process_WhenAbsMTPressureIsPresent_HoversIfIts toDisplayX(150), toDisplayY(250), 0, 0, 0, 0, 0, 0, 0, 0)); } -TEST_F(MultiTouchInputMapperTest, Process_HandlesTimestamp) { - MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); - - addConfigurationProperty("touch.deviceType", "touchScreen"); - prepareDisplay(DISPLAY_ORIENTATION_0); - prepareAxes(POSITION); - addMapperAndConfigure(mapper); - NotifyMotionArgs args; - - // By default, deviceTimestamp should be zero - processPosition(mapper, 100, 100); - processMTSync(mapper); - processSync(mapper); - ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); - ASSERT_EQ(0U, args.deviceTimestamp); - - // Now the timestamp of 1000 is reported by evdev and should appear in MotionArgs - processPosition(mapper, 0, 0); - processTimestamp(mapper, 1000); - processMTSync(mapper); - processSync(mapper); - ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); - ASSERT_EQ(1000U, args.deviceTimestamp); -} - -TEST_F(MultiTouchInputMapperTest, WhenMapperIsReset_TimestampIsCleared) { - MultiTouchInputMapper* mapper = new MultiTouchInputMapper(mDevice); - - addConfigurationProperty("touch.deviceType", "touchScreen"); - prepareDisplay(DISPLAY_ORIENTATION_0); - prepareAxes(POSITION); - addMapperAndConfigure(mapper); - NotifyMotionArgs args; - - // Send a touch event with a timestamp - processPosition(mapper, 100, 100); - processTimestamp(mapper, 1); - processMTSync(mapper); - processSync(mapper); - ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); - ASSERT_EQ(1U, args.deviceTimestamp); - - // Since the data accumulates, and new timestamp has not arrived, deviceTimestamp won't change - processPosition(mapper, 100, 200); - processMTSync(mapper); - processSync(mapper); - ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); - ASSERT_EQ(1U, args.deviceTimestamp); - - mapper->reset(/* when */ 0); - // After the mapper is reset, deviceTimestamp should become zero again - processPosition(mapper, 100, 300); - processMTSync(mapper); - processSync(mapper); - ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args)); - ASSERT_EQ(0U, args.deviceTimestamp); -} - /** * Set the input device port <--> display port associations, and check that the * events are routed to the display that matches the display port. diff --git a/services/surfaceflinger/BufferStateLayer.cpp b/services/surfaceflinger/BufferStateLayer.cpp index 2abc1a75a9..4b01301467 100644 --- a/services/surfaceflinger/BufferStateLayer.cpp +++ b/services/surfaceflinger/BufferStateLayer.cpp @@ -85,7 +85,7 @@ void BufferStateLayer::setTransformHint(uint32_t /*orientation*/) const { } void BufferStateLayer::releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) { - mFlinger->getTransactionCompletedThread().addPresentedCallbackHandles( + mFlinger->getTransactionCompletedThread().finalizePendingCallbackHandles( mDrawingState.callbackHandles); mDrawingState.callbackHandles = {}; @@ -310,7 +310,7 @@ bool BufferStateLayer::setTransactionCompletedListeners( } else { // If this layer will NOT need to be relatched and presented this frame // Notify the transaction completed thread this handle is done - mFlinger->getTransactionCompletedThread().addUnpresentedCallbackHandle(handle); + mFlinger->getTransactionCompletedThread().registerUnpresentedCallbackHandle(handle); } } diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp index 414c8dd23d..26c61ba54a 100644 --- a/services/surfaceflinger/Layer.cpp +++ b/services/surfaceflinger/Layer.cpp @@ -2011,6 +2011,13 @@ bool Layer::isRemovedFromCurrentState() const { return mRemovedFromCurrentState; } +// Debug helper for b/137560795 +#define INT32_MIGHT_OVERFLOW(n) (((n) >= INT32_MAX / 2) || ((n) <= INT32_MIN / 2)) + +#define RECT_BOUNDS_INVALID(rect) \ + (INT32_MIGHT_OVERFLOW((rect).left) || INT32_MIGHT_OVERFLOW((rect).right) || \ + INT32_MIGHT_OVERFLOW((rect).bottom) || INT32_MIGHT_OVERFLOW((rect).top)) + InputWindowInfo Layer::fillInputInfo() { InputWindowInfo info = mDrawingState.inputInfo; @@ -2040,6 +2047,26 @@ InputWindowInfo Layer::fillInputInfo() { layerBounds = getCroppedBufferSize(getDrawingState()); } layerBounds = t.transform(layerBounds); + + // debug check for b/137560795 + { + if (RECT_BOUNDS_INVALID(layerBounds)) { + ALOGE("layer %s bounds are invalid (%" PRIi32 ", %" PRIi32 ", %" PRIi32 ", %" PRIi32 + ")", + mName.c_str(), layerBounds.left, layerBounds.top, layerBounds.right, + layerBounds.bottom); + std::string out; + getTransform().dump(out, "Transform"); + ALOGE("%s", out.c_str()); + layerBounds.left = layerBounds.top = layerBounds.right = layerBounds.bottom = 0; + } + + if (INT32_MIGHT_OVERFLOW(xSurfaceInset) || INT32_MIGHT_OVERFLOW(ySurfaceInset)) { + ALOGE("layer %s surface inset are invalid (%" PRIi32 ", %" PRIi32 ")", mName.c_str(), + int32_t(xSurfaceInset), int32_t(ySurfaceInset)); + xSurfaceInset = ySurfaceInset = 0; + } + } layerBounds.inset(xSurfaceInset, ySurfaceInset, xSurfaceInset, ySurfaceInset); // Input coordinate should match the layer bounds. diff --git a/services/surfaceflinger/Scheduler/DispSync.cpp b/services/surfaceflinger/Scheduler/DispSync.cpp index 83fd42b43f..0c94052979 100644 --- a/services/surfaceflinger/Scheduler/DispSync.cpp +++ b/services/surfaceflinger/Scheduler/DispSync.cpp @@ -668,7 +668,13 @@ void DispSync::updateModelLocked() { nsecs_t durationSum = 0; nsecs_t minDuration = INT64_MAX; nsecs_t maxDuration = 0; - for (size_t i = 1; i < mNumResyncSamples; i++) { + // We skip the first 2 samples because the first vsync duration on some + // devices may be much more inaccurate than on other devices, e.g. due + // to delays in ramping up from a power collapse. By doing so this + // actually increases the accuracy of the DispSync model even though + // we're effectively relying on fewer sample points. + static constexpr size_t numSamplesSkipped = 2; + for (size_t i = numSamplesSkipped; i < mNumResyncSamples; i++) { size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES; size_t prev = (idx + MAX_RESYNC_SAMPLES - 1) % MAX_RESYNC_SAMPLES; nsecs_t duration = mResyncSamples[idx] - mResyncSamples[prev]; @@ -679,15 +685,14 @@ void DispSync::updateModelLocked() { // Exclude the min and max from the average durationSum -= minDuration + maxDuration; - mPeriod = durationSum / (mNumResyncSamples - 3); + mPeriod = durationSum / (mNumResyncSamples - numSamplesSkipped - 2); ALOGV("[%s] mPeriod = %" PRId64, mName, ns2us(mPeriod)); double sampleAvgX = 0; double sampleAvgY = 0; double scale = 2.0 * M_PI / double(mPeriod); - // Intentionally skip the first sample - for (size_t i = 1; i < mNumResyncSamples; i++) { + for (size_t i = numSamplesSkipped; i < mNumResyncSamples; i++) { size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES; nsecs_t sample = mResyncSamples[idx] - mReferenceTime; double samplePhase = double(sample % mPeriod) * scale; @@ -695,8 +700,8 @@ void DispSync::updateModelLocked() { sampleAvgY += sin(samplePhase); } - sampleAvgX /= double(mNumResyncSamples - 1); - sampleAvgY /= double(mNumResyncSamples - 1); + sampleAvgX /= double(mNumResyncSamples - numSamplesSkipped); + sampleAvgY /= double(mNumResyncSamples - numSamplesSkipped); mPhase = nsecs_t(atan2(sampleAvgY, sampleAvgX) / scale); diff --git a/services/surfaceflinger/Scheduler/DispSyncSource.cpp b/services/surfaceflinger/Scheduler/DispSyncSource.cpp index 026b55707c..5faf46e31e 100644 --- a/services/surfaceflinger/Scheduler/DispSyncSource.cpp +++ b/services/surfaceflinger/Scheduler/DispSyncSource.cpp @@ -78,6 +78,10 @@ void DispSyncSource::setPhaseOffset(nsecs_t phaseOffset) { // Normalize phaseOffset to [-period, period) const int numPeriods = phaseOffset / period; phaseOffset -= numPeriods * period; + if (mPhaseOffset == phaseOffset) { + return; + } + mPhaseOffset = phaseOffset; tracePhaseOffset(); diff --git a/services/surfaceflinger/Scheduler/LayerInfo.cpp b/services/surfaceflinger/Scheduler/LayerInfo.cpp index beddb9be61..e782dd5361 100644 --- a/services/surfaceflinger/Scheduler/LayerInfo.cpp +++ b/services/surfaceflinger/Scheduler/LayerInfo.cpp @@ -50,7 +50,8 @@ void LayerInfo::setLastPresentTime(nsecs_t lastPresentTime) { // Ignore time diff that are too high - those are stale values if (timeDiff > OBSOLETE_TIME_EPSILON_NS.count()) return; const nsecs_t refreshDuration = (timeDiff > 0) ? timeDiff : mMinRefreshDuration; - mRefreshRateHistory.insertRefreshRate(refreshDuration); + const int fps = 1e9f / refreshDuration; + mRefreshRateHistory.insertRefreshRate(fps); } } // namespace scheduler diff --git a/services/surfaceflinger/Scheduler/LayerInfo.h b/services/surfaceflinger/Scheduler/LayerInfo.h index 2c50053ebd..a7337817e3 100644 --- a/services/surfaceflinger/Scheduler/LayerInfo.h +++ b/services/surfaceflinger/Scheduler/LayerInfo.h @@ -46,7 +46,7 @@ class LayerInfo { public: explicit RefreshRateHistory(nsecs_t minRefreshDuration) : mMinRefreshDuration(minRefreshDuration) {} - void insertRefreshRate(nsecs_t refreshRate) { + void insertRefreshRate(int refreshRate) { mElements.push_back(refreshRate); if (mElements.size() > HISTORY_SIZE) { mElements.pop_front(); @@ -54,13 +54,13 @@ class LayerInfo { } float getRefreshRateAvg() const { - nsecs_t refreshDuration = mMinRefreshDuration; - if (mElements.size() > 0) { - refreshDuration = scheduler::calculate_mean(mElements); + if (mElements.empty()) { + return 1e9f / mMinRefreshDuration; } - return 1e9f / refreshDuration; + return scheduler::calculate_mean(mElements); } + void clearHistory() { mElements.clear(); } private: @@ -129,8 +129,8 @@ class LayerInfo { private: std::deque<nsecs_t> mElements; - static constexpr size_t HISTORY_SIZE = 10; - static constexpr std::chrono::nanoseconds HISTORY_TIME = 500ms; + static constexpr size_t HISTORY_SIZE = 90; + static constexpr std::chrono::nanoseconds HISTORY_TIME = 1s; }; public: diff --git a/services/surfaceflinger/Scheduler/Scheduler.cpp b/services/surfaceflinger/Scheduler/Scheduler.cpp index 27f42d23a3..7acb4701d9 100644 --- a/services/surfaceflinger/Scheduler/Scheduler.cpp +++ b/services/surfaceflinger/Scheduler/Scheduler.cpp @@ -76,6 +76,7 @@ Scheduler::Scheduler(impl::EventControlThread::SetVSyncEnabledFunction function, mSupportKernelTimer = support_kernel_idle_timer(false); mSetTouchTimerMs = set_touch_timer_ms(0); + mSetDisplayPowerTimerMs = set_display_power_timer_ms(0); char value[PROPERTY_VALUE_MAX]; property_get("debug.sf.set_idle_timer_ms", value, "0"); @@ -105,10 +106,19 @@ Scheduler::Scheduler(impl::EventControlThread::SetVSyncEnabledFunction function, [this] { expiredTouchTimerCallback(); }); mTouchTimer->start(); } + + if (mSetDisplayPowerTimerMs > 0) { + mDisplayPowerTimer = std::make_unique<scheduler::OneShotTimer>( + std::chrono::milliseconds(mSetDisplayPowerTimerMs), + [this] { resetDisplayPowerTimerCallback(); }, + [this] { expiredDisplayPowerTimerCallback(); }); + mDisplayPowerTimer->start(); + } } Scheduler::~Scheduler() { // Ensure the OneShotTimer threads are joined before we start destroying state. + mDisplayPowerTimer.reset(); mTouchTimer.reset(); mIdleTimer.reset(); } @@ -375,11 +385,17 @@ void Scheduler::updateFpsBasedOnContent() { } void Scheduler::setChangeRefreshRateCallback( - const ChangeRefreshRateCallback& changeRefreshRateCallback) { + const ChangeRefreshRateCallback&& changeRefreshRateCallback) { std::lock_guard<std::mutex> lock(mCallbackLock); mChangeRefreshRateCallback = changeRefreshRateCallback; } +void Scheduler::setGetCurrentRefreshRateTypeCallback( + const GetCurrentRefreshRateTypeCallback&& getCurrentRefreshRateTypeCallback) { + std::lock_guard<std::mutex> lock(mCallbackLock); + mGetCurrentRefreshRateTypeCallback = getCurrentRefreshRateTypeCallback; +} + void Scheduler::setGetVsyncPeriodCallback(const GetVsyncPeriod&& getVsyncPeriod) { std::lock_guard<std::mutex> lock(mCallbackLock); mGetVsyncPeriod = getVsyncPeriod; @@ -414,41 +430,75 @@ void Scheduler::notifyTouchEvent() { mLayerHistory.clearHistory(); } +void Scheduler::setDisplayPowerState(bool normal) { + { + std::lock_guard<std::mutex> lock(mFeatureStateLock); + mIsDisplayPowerStateNormal = normal; + } + + if (mDisplayPowerTimer) { + mDisplayPowerTimer->reset(); + } + + // Display Power event will boost the refresh rate to performance. + // Clear Layer History to get fresh FPS detection + mLayerHistory.clearHistory(); +} + void Scheduler::resetTimerCallback() { - timerChangeRefreshRate(IdleTimerState::RESET); + handleTimerStateChanged(&mCurrentIdleTimerState, IdleTimerState::RESET, false); ATRACE_INT("ExpiredIdleTimer", 0); } void Scheduler::resetKernelTimerCallback() { ATRACE_INT("ExpiredKernelIdleTimer", 0); std::lock_guard<std::mutex> lock(mCallbackLock); - if (mGetVsyncPeriod) { - resyncToHardwareVsync(true, mGetVsyncPeriod()); + if (mGetVsyncPeriod && mGetCurrentRefreshRateTypeCallback) { + // If we're not in performance mode then the kernel timer shouldn't do + // anything, as the refresh rate during DPU power collapse will be the + // same. + if (mGetCurrentRefreshRateTypeCallback() == Scheduler::RefreshRateType::PERFORMANCE) { + resyncToHardwareVsync(true, mGetVsyncPeriod()); + } } } void Scheduler::expiredTimerCallback() { - timerChangeRefreshRate(IdleTimerState::EXPIRED); + handleTimerStateChanged(&mCurrentIdleTimerState, IdleTimerState::EXPIRED, false); ATRACE_INT("ExpiredIdleTimer", 1); } void Scheduler::resetTouchTimerCallback() { - // We do not notify the applications about config changes when idle timer is reset. - touchChangeRefreshRate(TouchState::ACTIVE); + handleTimerStateChanged(&mCurrentTouchState, TouchState::ACTIVE, true); ATRACE_INT("TouchState", 1); } void Scheduler::expiredTouchTimerCallback() { - // We do not notify the applications about config changes when idle timer expires. - touchChangeRefreshRate(TouchState::INACTIVE); + handleTimerStateChanged(&mCurrentTouchState, TouchState::INACTIVE, true); ATRACE_INT("TouchState", 0); } +void Scheduler::resetDisplayPowerTimerCallback() { + handleTimerStateChanged(&mDisplayPowerTimerState, DisplayPowerTimerState::RESET, true); + ATRACE_INT("ExpiredDisplayPowerTimer", 0); +} + +void Scheduler::expiredDisplayPowerTimerCallback() { + handleTimerStateChanged(&mDisplayPowerTimerState, DisplayPowerTimerState::EXPIRED, true); + ATRACE_INT("ExpiredDisplayPowerTimer", 1); +} + void Scheduler::expiredKernelTimerCallback() { + std::lock_guard<std::mutex> lock(mCallbackLock); ATRACE_INT("ExpiredKernelIdleTimer", 1); - // Disable HW Vsync if the timer expired, as we don't need it - // enabled if we're not pushing frames. - disableHardwareVsync(false); + if (mGetCurrentRefreshRateTypeCallback) { + if (mGetCurrentRefreshRateTypeCallback() != Scheduler::RefreshRateType::PERFORMANCE) { + // Disable HW Vsync if the timer expired, as we don't need it + // enabled if we're not pushing frames, and if we're in PERFORMANCE + // mode then we'll need to re-update the DispSync model anyways. + disableHardwareVsync(false); + } + } } std::string Scheduler::doDump() { @@ -458,39 +508,23 @@ std::string Scheduler::doDump() { return stream.str(); } -void Scheduler::timerChangeRefreshRate(IdleTimerState idleTimerState) { - RefreshRateType newRefreshRateType; - { - std::lock_guard<std::mutex> lock(mFeatureStateLock); - if (mCurrentIdleTimerState == idleTimerState) { - return; - } - mCurrentIdleTimerState = idleTimerState; - newRefreshRateType = calculateRefreshRateType(); - if (mRefreshRateType == newRefreshRateType) { - return; - } - mRefreshRateType = newRefreshRateType; - } - changeRefreshRate(newRefreshRateType, ConfigEvent::None); -} - -void Scheduler::touchChangeRefreshRate(TouchState touchState) { +template <class T> +void Scheduler::handleTimerStateChanged(T* currentState, T newState, bool eventOnContentDetection) { ConfigEvent event = ConfigEvent::None; RefreshRateType newRefreshRateType; { std::lock_guard<std::mutex> lock(mFeatureStateLock); - if (mCurrentTouchState == touchState) { + if (*currentState == newState) { return; } - mCurrentTouchState = touchState; + *currentState = newState; newRefreshRateType = calculateRefreshRateType(); if (mRefreshRateType == newRefreshRateType) { return; } mRefreshRateType = newRefreshRateType; - // Send an event in case that content detection is on as touch has a higher priority - if (mCurrentContentFeatureState == ContentFeatureState::CONTENT_DETECTION_ON) { + if (eventOnContentDetection && + mCurrentContentFeatureState == ContentFeatureState::CONTENT_DETECTION_ON) { event = ConfigEvent::Changed; } } @@ -503,6 +537,12 @@ Scheduler::RefreshRateType Scheduler::calculateRefreshRateType() { return RefreshRateType::DEFAULT; } + // If Display Power is not in normal operation we want to be in performance mode. + // When coming back to normal mode, a grace period is given with DisplayPowerTimer + if (!mIsDisplayPowerStateNormal || mDisplayPowerTimerState == DisplayPowerTimerState::RESET) { + return RefreshRateType::PERFORMANCE; + } + // As long as touch is active we want to be in performance mode if (mCurrentTouchState == TouchState::ACTIVE) { return RefreshRateType::PERFORMANCE; diff --git a/services/surfaceflinger/Scheduler/Scheduler.h b/services/surfaceflinger/Scheduler/Scheduler.h index a30776059f..123036e0fa 100644 --- a/services/surfaceflinger/Scheduler/Scheduler.h +++ b/services/surfaceflinger/Scheduler/Scheduler.h @@ -49,6 +49,7 @@ public: } using RefreshRateType = scheduler::RefreshRateConfigs::RefreshRateType; + using GetCurrentRefreshRateTypeCallback = std::function<RefreshRateType()>; using ChangeRefreshRateCallback = std::function<void(RefreshRateType, ConfigEvent)>; using GetVsyncPeriod = std::function<nsecs_t()>; @@ -165,7 +166,9 @@ public: // Updates FPS based on the most content presented. void updateFpsBasedOnContent(); // Callback that gets invoked when Scheduler wants to change the refresh rate. - void setChangeRefreshRateCallback(const ChangeRefreshRateCallback& changeRefreshRateCallback); + void setChangeRefreshRateCallback(const ChangeRefreshRateCallback&& changeRefreshRateCallback); + void setGetCurrentRefreshRateTypeCallback( + const GetCurrentRefreshRateTypeCallback&& getCurrentRefreshRateType); void setGetVsyncPeriodCallback(const GetVsyncPeriod&& getVsyncPeriod); // Returns whether idle timer is enabled or not @@ -177,6 +180,9 @@ public: // Function that resets the touch timer. void notifyTouchEvent(); + // Function that sets whether display power mode is normal or not. + void setDisplayPowerState(bool normal); + // Returns relevant information about Scheduler for dumpsys purposes. std::string doDump(); @@ -197,6 +203,7 @@ private: enum class ContentFeatureState { CONTENT_DETECTION_ON, CONTENT_DETECTION_OFF }; enum class IdleTimerState { EXPIRED, RESET }; enum class TouchState { INACTIVE, ACTIVE }; + enum class DisplayPowerTimerState { EXPIRED, RESET }; // Creates a connection on the given EventThread and forwards the given callbacks. sp<EventThreadConnection> createConnectionInternal(EventThread*, ResyncCallback&&, @@ -221,12 +228,15 @@ private: void resetTouchTimerCallback(); // Function that is called when the touch timer expires. void expiredTouchTimerCallback(); + // Function that is called when the display power timer resets. + void resetDisplayPowerTimerCallback(); + // Function that is called when the display power timer expires. + void expiredDisplayPowerTimerCallback(); // Sets vsync period. void setVsyncPeriod(const nsecs_t period); - // Idle timer feature's function to change the refresh rate. - void timerChangeRefreshRate(IdleTimerState idleTimerState); - // Touch timer feature's function to change the refresh rate. - void touchChangeRefreshRate(TouchState touchState); + // handles various timer features to change the refresh rate. + template <class T> + void handleTimerStateChanged(T* currentState, T newState, bool eventOnContentDetection); // Calculate the new refresh rate type RefreshRateType calculateRefreshRateType() REQUIRES(mFeatureStateLock); // Acquires a lock and calls the ChangeRefreshRateCallback() with given parameters. @@ -282,7 +292,12 @@ private: int64_t mSetTouchTimerMs = 0; std::unique_ptr<scheduler::OneShotTimer> mTouchTimer; + // Timer used to monitor display power mode. + int64_t mSetDisplayPowerTimerMs = 0; + std::unique_ptr<scheduler::OneShotTimer> mDisplayPowerTimer; + std::mutex mCallbackLock; + GetCurrentRefreshRateTypeCallback mGetCurrentRefreshRateTypeCallback GUARDED_BY(mCallbackLock); ChangeRefreshRateCallback mChangeRefreshRateCallback GUARDED_BY(mCallbackLock); GetVsyncPeriod mGetVsyncPeriod GUARDED_BY(mCallbackLock); @@ -293,9 +308,12 @@ private: ContentFeatureState::CONTENT_DETECTION_OFF; IdleTimerState mCurrentIdleTimerState GUARDED_BY(mFeatureStateLock) = IdleTimerState::RESET; TouchState mCurrentTouchState GUARDED_BY(mFeatureStateLock) = TouchState::INACTIVE; + DisplayPowerTimerState mDisplayPowerTimerState GUARDED_BY(mFeatureStateLock) = + DisplayPowerTimerState::EXPIRED; uint32_t mContentRefreshRate GUARDED_BY(mFeatureStateLock); RefreshRateType mRefreshRateType GUARDED_BY(mFeatureStateLock); bool mIsHDRContent GUARDED_BY(mFeatureStateLock) = false; + bool mIsDisplayPowerStateNormal GUARDED_BY(mFeatureStateLock) = true; const scheduler::RefreshRateConfigs& mRefreshRateConfigs; diff --git a/services/surfaceflinger/Scheduler/VSyncModulator.cpp b/services/surfaceflinger/Scheduler/VSyncModulator.cpp index d452c19b68..7a3bf8edaf 100644 --- a/services/surfaceflinger/Scheduler/VSyncModulator.cpp +++ b/services/surfaceflinger/Scheduler/VSyncModulator.cpp @@ -129,29 +129,16 @@ void VSyncModulator::updateOffsets() { void VSyncModulator::updateOffsetsLocked() { const Offsets desired = getNextOffsets(); - const Offsets current = mOffsets; - - bool changed = false; - if (desired.sf != current.sf) { - if (mSfConnectionHandle != nullptr) { - mScheduler->setPhaseOffset(mSfConnectionHandle, desired.sf); - } else if (mSfEventThread != nullptr) { - mSfEventThread->setPhaseOffset(desired.sf); - } - changed = true; - } - if (desired.app != current.app) { - if (mAppConnectionHandle != nullptr) { - mScheduler->setPhaseOffset(mAppConnectionHandle, desired.app); - } else if (mAppEventThread != nullptr) { - mAppEventThread->setPhaseOffset(desired.app); - } - changed = true; + + if (mSfConnectionHandle != nullptr) { + mScheduler->setPhaseOffset(mSfConnectionHandle, desired.sf); } - if (changed) { - flushOffsets(); + if (mAppConnectionHandle != nullptr) { + mScheduler->setPhaseOffset(mAppConnectionHandle, desired.app); } + + flushOffsets(); } void VSyncModulator::flushOffsets() { diff --git a/services/surfaceflinger/Scheduler/VSyncModulator.h b/services/surfaceflinger/Scheduler/VSyncModulator.h index 10cf8e6cc9..ddbd221ef1 100644 --- a/services/surfaceflinger/Scheduler/VSyncModulator.h +++ b/services/surfaceflinger/Scheduler/VSyncModulator.h @@ -68,12 +68,6 @@ public: void setPhaseOffsets(Offsets early, Offsets earlyGl, Offsets late, nsecs_t thresholdForNextVsync) EXCLUDES(mMutex); - // Sets handles to the SF and app event threads. - void setEventThreads(EventThread* sfEventThread, EventThread* appEventThread) { - mSfEventThread = sfEventThread; - mAppEventThread = appEventThread; - } - // Sets the scheduler and vsync connection handlers. void setSchedulerAndHandles(Scheduler* scheduler, Scheduler::ConnectionHandle* appConnectionHandle, @@ -121,9 +115,6 @@ private: std::unordered_map<OffsetType, Offsets> mOffsetMap GUARDED_BY(mMutex); nsecs_t mThresholdForNextVsync; - EventThread* mSfEventThread = nullptr; - EventThread* mAppEventThread = nullptr; - Scheduler* mScheduler = nullptr; Scheduler::ConnectionHandle* mAppConnectionHandle = nullptr; Scheduler::ConnectionHandle* mSfConnectionHandle = nullptr; diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp index 47c17d0e51..99440a6d5e 100644 --- a/services/surfaceflinger/SurfaceFlinger.cpp +++ b/services/surfaceflinger/SurfaceFlinger.cpp @@ -48,6 +48,8 @@ #include <compositionengine/impl/OutputLayerCompositionState.h> #include <dvr/vr_flinger.h> #include <gui/BufferQueue.h> +#include <gui/DebugEGLImageTracker.h> + #include <gui/GuiConfig.h> #include <gui/IDisplayEventConnection.h> #include <gui/IProducerListener.h> @@ -356,6 +358,11 @@ SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipI mPropagateBackpressure = !atoi(value); ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation"); + property_get("debug.sf.enable_gl_backpressure", value, "0"); + mPropagateBackpressureClientComposition = atoi(value); + ALOGI_IF(mPropagateBackpressureClientComposition, + "Enabling backpressure propagation for Client Composition"); + property_get("debug.sf.enable_hwc_vds", value, "0"); mUseHwcVirtualDisplays = atoi(value); ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays"); @@ -713,6 +720,24 @@ void SurfaceFlinger::init() { Mutex::Autolock lock(mStateLock); setRefreshRateTo(type, event); }); + mScheduler->setGetCurrentRefreshRateTypeCallback([this] { + Mutex::Autolock lock(mStateLock); + const auto display = getDefaultDisplayDeviceLocked(); + if (!display) { + // If we don't have a default display the fallback to the default + // refresh rate type + return RefreshRateType::DEFAULT; + } + + const int configId = display->getActiveConfig(); + for (const auto& [type, refresh] : mRefreshRateConfigs.getRefreshRates()) { + if (refresh && refresh->configId == configId) { + return type; + } + } + // This should never happen, but just gracefully fallback to default. + return RefreshRateType::DEFAULT; + }); mScheduler->setGetVsyncPeriodCallback([this] { Mutex::Autolock lock(mStateLock); return getVsyncPeriod(); @@ -1045,6 +1070,7 @@ bool SurfaceFlinger::performSetActiveConfig() { desiredActiveConfigChangeDone(); return false; } + mUpcomingActiveConfig = desiredActiveConfig; const auto displayId = display->getId(); LOG_ALWAYS_FATAL_IF(!displayId); @@ -1667,22 +1693,26 @@ bool SurfaceFlinger::previousFrameMissed() NO_THREAD_SAFETY_ANALYSIS { return fence != Fence::NO_FENCE && (fence->getStatus() == Fence::Status::Unsignaled); } -nsecs_t SurfaceFlinger::getExpectedPresentTime() NO_THREAD_SAFETY_ANALYSIS { +void SurfaceFlinger::populateExpectedPresentTime() NO_THREAD_SAFETY_ANALYSIS { DisplayStatInfo stats; mScheduler->getDisplayStatInfo(&stats); const nsecs_t presentTime = mScheduler->getDispSyncExpectedPresentTime(); // Inflate the expected present time if we're targetting the next vsync. - const nsecs_t correctedTime = + mExpectedPresentTime = mVsyncModulator.getOffsets().sf < mPhaseOffsets->getOffsetThresholdForNextVsync() ? presentTime : presentTime + stats.vsyncPeriod; - return correctedTime; } void SurfaceFlinger::onMessageReceived(int32_t what) NO_THREAD_SAFETY_ANALYSIS { ATRACE_CALL(); switch (what) { case MessageQueue::INVALIDATE: { + // calculate the expected present time once and use the cached + // value throughout this frame to make sure all layers are + // seeing this same value. + populateExpectedPresentTime(); + bool frameMissed = previousFrameMissed(); bool hwcFrameMissed = mHadDeviceComposition && frameMissed; bool gpuFrameMissed = mHadClientComposition && frameMissed; @@ -1712,9 +1742,9 @@ void SurfaceFlinger::onMessageReceived(int32_t what) NO_THREAD_SAFETY_ANALYSIS { break; } - // For now, only propagate backpressure when missing a hwc frame. - if (hwcFrameMissed && !gpuFrameMissed) { - if (mPropagateBackpressure) { + if (frameMissed && mPropagateBackpressure) { + if ((hwcFrameMissed && !gpuFrameMissed) || + mPropagateBackpressureClientComposition) { signalLayerUpdate(); break; } @@ -2183,14 +2213,7 @@ void SurfaceFlinger::postComposition() } mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]); - - // Lock the mStateLock in case SurfaceFlinger is in the middle of applying a transaction. - // If we do not lock here, a callback could be sent without all of its SurfaceControls and - // metrics. - { - Mutex::Autolock _l(mStateLock); - mTransactionCompletedThread.sendCallbacks(); - } + mTransactionCompletedThread.sendCallbacks(); if (mLumaSampling && mRegionSamplingThread) { mRegionSamplingThread->notifyNewContent(); @@ -3790,8 +3813,8 @@ void SurfaceFlinger::applyTransactionState(const Vector<ComposerState>& states, if (!listenerCallbacks.empty()) { mTransactionCompletedThread.run(); } - for (const auto& [listener, callbackIds] : listenerCallbacks) { - mTransactionCompletedThread.addCallback(listener, callbackIds); + for (const auto& listenerCallback : listenerCallbacks) { + mTransactionCompletedThread.startRegistration(listenerCallback); } uint32_t clientStateFlags = 0; @@ -3800,6 +3823,10 @@ void SurfaceFlinger::applyTransactionState(const Vector<ComposerState>& states, postTime, privileged); } + for (const auto& listenerCallback : listenerCallbacks) { + mTransactionCompletedThread.endRegistration(listenerCallback); + } + // If the state doesn't require a traversal and there are callbacks, send them now if (!(clientStateFlags & eTraversalNeeded) && !listenerCallbacks.empty()) { mTransactionCompletedThread.sendCallbacks(); @@ -3937,7 +3964,7 @@ uint32_t SurfaceFlinger::setClientStateLocked( sp<Layer> layer(client->getLayerUser(s.surface)); if (layer == nullptr) { for (auto& listenerCallback : listenerCallbacks) { - mTransactionCompletedThread.addUnpresentedCallbackHandle( + mTransactionCompletedThread.registerUnpresentedCallbackHandle( new CallbackHandle(listenerCallback.transactionCompletedListener, listenerCallback.callbackIds, s.surface)); } @@ -4545,6 +4572,7 @@ void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, int if (display->isPrimary()) { mTimeStats->setPowerMode(mode); mRefreshRateStats.setPowerMode(mode); + mScheduler->setDisplayPowerState(mode == HWC_POWER_MODE_NORMAL); } ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str()); @@ -5002,6 +5030,8 @@ void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) co getRenderEngine().dump(result); + DebugEGLImageTracker::getInstance()->dump(result); + if (const auto display = getDefaultDisplayDeviceLocked()) { display->getCompositionDisplay()->getState().undefinedRegion.dump(result, "undefinedRegion"); @@ -5191,7 +5221,18 @@ status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) { case SET_DISPLAY_BRIGHTNESS: { return OK; } - case CAPTURE_LAYERS: + case CAPTURE_LAYERS: { + IPCThreadState* ipc = IPCThreadState::self(); + const int pid = ipc->getCallingPid(); + const int uid = ipc->getCallingUid(); + // allow media to capture layer for video thumbnails + if ((uid != AID_GRAPHICS && uid != AID_MEDIA) && + !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) { + ALOGE("Permission Denial: can't capture layer pid=%d, uid=%d", pid, uid); + return PERMISSION_DENIED; + } + return OK; + } case CAPTURE_SCREEN: case ADD_REGION_SAMPLING_LISTENER: case REMOVE_REGION_SAMPLING_LISTENER: { @@ -5415,7 +5456,12 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r return NO_ERROR; } case 1023: { // Set native mode + int32_t colorMode; + mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32()); + if (data.readInt32(&colorMode) == NO_ERROR) { + mForceColorMode = static_cast<ColorMode>(colorMode); + } invalidateHwcGeometry(); repaintEverything(); return NO_ERROR; diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h index fa801afff8..0e6eacf72b 100644 --- a/services/surfaceflinger/SurfaceFlinger.h +++ b/services/surfaceflinger/SurfaceFlinger.h @@ -301,10 +301,11 @@ public: // TODO: this should be made accessible only to MessageQueue void onMessageReceived(int32_t what); - // Returns the expected present time for this frame. + // populates the expected present time for this frame. // When we are in negative offsets, we perform a correction so that the // predicted vsync for the *next* frame is used instead. - nsecs_t getExpectedPresentTime(); + void populateExpectedPresentTime(); + nsecs_t getExpectedPresentTime() const { return mExpectedPresentTime; } // for debugging only // TODO: this should be made accessible only to HWComposer @@ -1015,6 +1016,7 @@ private: volatile nsecs_t mDebugInTransaction = 0; bool mForceFullDamage = false; bool mPropagateBackpressure = true; + bool mPropagateBackpressureClientComposition = false; std::unique_ptr<SurfaceInterceptor> mInterceptor; SurfaceTracing mTracing{*this}; bool mTracingEnabled = false; @@ -1186,6 +1188,8 @@ private: // Flags to capture the state of Vsync in HWC HWC2::Vsync mHWCVsyncState = HWC2::Vsync::Disable; HWC2::Vsync mHWCVsyncPendingState = HWC2::Vsync::Disable; + + nsecs_t mExpectedPresentTime; }; } // namespace android diff --git a/services/surfaceflinger/SurfaceFlingerProperties.cpp b/services/surfaceflinger/SurfaceFlingerProperties.cpp index 237208d39f..768074a6cd 100644 --- a/services/surfaceflinger/SurfaceFlingerProperties.cpp +++ b/services/surfaceflinger/SurfaceFlingerProperties.cpp @@ -242,6 +242,14 @@ int32_t set_touch_timer_ms(int32_t defaultValue) { return defaultValue; } +int32_t set_display_power_timer_ms(int32_t defaultValue) { + auto temp = SurfaceFlingerProperties::set_display_power_timer_ms(); + if (temp.has_value()) { + return *temp; + } + return defaultValue; +} + bool use_smart_90_for_video(bool defaultValue) { auto temp = SurfaceFlingerProperties::use_smart_90_for_video(); if (temp.has_value()) { diff --git a/services/surfaceflinger/SurfaceFlingerProperties.h b/services/surfaceflinger/SurfaceFlingerProperties.h index b5418d6538..5f88322f71 100644 --- a/services/surfaceflinger/SurfaceFlingerProperties.h +++ b/services/surfaceflinger/SurfaceFlingerProperties.h @@ -77,6 +77,8 @@ int32_t set_idle_timer_ms(int32_t defaultValue); int32_t set_touch_timer_ms(int32_t defaultValue); +int32_t set_display_power_timer_ms(int32_t defaultValue); + bool use_smart_90_for_video(bool defaultValue); bool enable_protected_contents(bool defaultValue); diff --git a/services/surfaceflinger/SurfaceInterceptor.cpp b/services/surfaceflinger/SurfaceInterceptor.cpp index 7bfe0338f7..a02d14cc4d 100644 --- a/services/surfaceflinger/SurfaceInterceptor.cpp +++ b/services/surfaceflinger/SurfaceInterceptor.cpp @@ -116,7 +116,14 @@ void SurfaceInterceptor::addInitialSurfaceStateLocked(Increment* increment, layer->mCurrentState.frameNumber_legacy); } addOverrideScalingModeLocked(transaction, layerId, layer->getEffectiveScalingMode()); - addFlagsLocked(transaction, layerId, layer->mCurrentState.flags); + addFlagsLocked(transaction, layerId, layer->mCurrentState.flags, + layer_state_t::eLayerHidden | layer_state_t::eLayerOpaque | + layer_state_t::eLayerSecure); + addReparentLocked(transaction, layerId, getLayerIdFromWeakRef(layer->mCurrentParent)); + addDetachChildrenLocked(transaction, layerId, layer->isLayerDetached()); + addRelativeParentLocked(transaction, layerId, + getLayerIdFromWeakRef(layer->mCurrentState.zOrderRelativeOf), + layer->mCurrentState.z); } void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment, @@ -150,7 +157,7 @@ status_t SurfaceInterceptor::writeProtoFileLocked() { return NO_ERROR; } -const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weakHandle) { +const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weakHandle) const { const sp<const IBinder>& handle(weakHandle.promote()); const auto layerHandle(static_cast<const Layer::Handle*>(handle.get())); const sp<const Layer> layer(layerHandle->owner.promote()); @@ -158,14 +165,31 @@ const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weak return layer; } -const std::string SurfaceInterceptor::getLayerName(const sp<const Layer>& layer) { +const std::string SurfaceInterceptor::getLayerName(const sp<const Layer>& layer) const { return layer->getName().string(); } -int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) { +int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) const { return layer->sequence; } +int32_t SurfaceInterceptor::getLayerIdFromWeakRef(const wp<const Layer>& layer) const { + if (layer == nullptr) { + return -1; + } + auto strongLayer = layer.promote(); + return strongLayer == nullptr ? -1 : getLayerId(strongLayer); +} + +int32_t SurfaceInterceptor::getLayerIdFromHandle(const sp<const IBinder>& handle) const { + if (handle == nullptr) { + return -1; + } + const auto layerHandle(static_cast<const Layer::Handle*>(handle.get())); + const sp<const Layer> layer(layerHandle->owner.promote()); + return layer == nullptr ? -1 : getLayerId(layer); +} + Increment* SurfaceInterceptor::createTraceIncrementLocked() { Increment* increment(mTrace.add_increment()); increment->set_time_stamp(systemTime()); @@ -252,24 +276,23 @@ void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction, } } -void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, - uint8_t flags) -{ +void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags, + uint8_t mask) { // There can be multiple flags changed - if (flags & layer_state_t::eLayerHidden) { + if (mask & layer_state_t::eLayerHidden) { SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); HiddenFlagChange* flagChange(change->mutable_hidden_flag()); - flagChange->set_hidden_flag(true); + flagChange->set_hidden_flag(flags & layer_state_t::eLayerHidden); } - if (flags & layer_state_t::eLayerOpaque) { + if (mask & layer_state_t::eLayerOpaque) { SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); OpaqueFlagChange* flagChange(change->mutable_opaque_flag()); - flagChange->set_opaque_flag(true); + flagChange->set_opaque_flag(flags & layer_state_t::eLayerOpaque); } - if (flags & layer_state_t::eLayerSecure) { + if (mask & layer_state_t::eLayerSecure) { SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); SecureFlagChange* flagChange(change->mutable_secure_flag()); - flagChange->set_secure_flag(true); + flagChange->set_secure_flag(flags & layer_state_t::eLayerSecure); } } @@ -320,6 +343,35 @@ void SurfaceInterceptor::addOverrideScalingModeLocked(Transaction* transaction, overrideChange->set_override_scaling_mode(overrideScalingMode); } +void SurfaceInterceptor::addReparentLocked(Transaction* transaction, int32_t layerId, + int32_t parentId) { + SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); + ReparentChange* overrideChange(change->mutable_reparent()); + overrideChange->set_parent_id(parentId); +} + +void SurfaceInterceptor::addReparentChildrenLocked(Transaction* transaction, int32_t layerId, + int32_t parentId) { + SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); + ReparentChildrenChange* overrideChange(change->mutable_reparent_children()); + overrideChange->set_parent_id(parentId); +} + +void SurfaceInterceptor::addDetachChildrenLocked(Transaction* transaction, int32_t layerId, + bool detached) { + SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); + DetachChildrenChange* overrideChange(change->mutable_detach_children()); + overrideChange->set_detach_children(detached); +} + +void SurfaceInterceptor::addRelativeParentLocked(Transaction* transaction, int32_t layerId, + int32_t parentId, int z) { + SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); + RelativeParentChange* overrideChange(change->mutable_relative_parent()); + overrideChange->set_relative_parent_id(parentId); + overrideChange->set_z(z); +} + void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction, const layer_state_t& state) { @@ -351,7 +403,7 @@ void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction, addTransparentRegionLocked(transaction, layerId, state.transparentRegion); } if (state.what & layer_state_t::eFlagsChanged) { - addFlagsLocked(transaction, layerId, state.flags); + addFlagsLocked(transaction, layerId, state.flags, state.mask); } if (state.what & layer_state_t::eLayerStackChanged) { addLayerStackLocked(transaction, layerId, state.layerStack); @@ -380,6 +432,19 @@ void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction, if (state.what & layer_state_t::eOverrideScalingModeChanged) { addOverrideScalingModeLocked(transaction, layerId, state.overrideScalingMode); } + if (state.what & layer_state_t::eReparent) { + addReparentLocked(transaction, layerId, getLayerIdFromHandle(state.parentHandleForChild)); + } + if (state.what & layer_state_t::eReparentChildren) { + addReparentChildrenLocked(transaction, layerId, getLayerIdFromHandle(state.reparentHandle)); + } + if (state.what & layer_state_t::eDetachChildren) { + addDetachChildrenLocked(transaction, layerId, true); + } + if (state.what & layer_state_t::eRelativeLayerChanged) { + addRelativeParentLocked(transaction, layerId, + getLayerIdFromHandle(state.relativeLayerHandle), state.z); + } } void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction, diff --git a/services/surfaceflinger/SurfaceInterceptor.h b/services/surfaceflinger/SurfaceInterceptor.h index 563a44c088..7f86c1423a 100644 --- a/services/surfaceflinger/SurfaceInterceptor.h +++ b/services/surfaceflinger/SurfaceInterceptor.h @@ -116,9 +116,11 @@ private: void addInitialDisplayStateLocked(Increment* increment, const DisplayDeviceState& display); status_t writeProtoFileLocked(); - const sp<const Layer> getLayer(const wp<const IBinder>& weakHandle); - const std::string getLayerName(const sp<const Layer>& layer); - int32_t getLayerId(const sp<const Layer>& layer); + const sp<const Layer> getLayer(const wp<const IBinder>& weakHandle) const; + const std::string getLayerName(const sp<const Layer>& layer) const; + int32_t getLayerId(const sp<const Layer>& layer) const; + int32_t getLayerIdFromWeakRef(const wp<const Layer>& layer) const; + int32_t getLayerIdFromHandle(const sp<const IBinder>& weakHandle) const; Increment* createTraceIncrementLocked(); void addSurfaceCreationLocked(Increment* increment, const sp<const Layer>& layer); @@ -141,7 +143,7 @@ private: const layer_state_t::matrix22_t& matrix); void addTransparentRegionLocked(Transaction* transaction, int32_t layerId, const Region& transRegion); - void addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags); + void addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags, uint8_t mask); void addLayerStackLocked(Transaction* transaction, int32_t layerId, uint32_t layerStack); void addCropLocked(Transaction* transaction, int32_t layerId, const Rect& rect); void addCornerRadiusLocked(Transaction* transaction, int32_t layerId, float cornerRadius); @@ -153,6 +155,11 @@ private: void addTransactionLocked(Increment* increment, const Vector<ComposerState>& stateUpdates, const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays, const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags); + void addReparentLocked(Transaction* transaction, int32_t layerId, int32_t parentId); + void addReparentChildrenLocked(Transaction* transaction, int32_t layerId, int32_t parentId); + void addDetachChildrenLocked(Transaction* transaction, int32_t layerId, bool detached); + void addRelativeParentLocked(Transaction* transaction, int32_t layerId, int32_t parentId, + int z); // Add display transactions to the trace DisplayChange* createDisplayChangeLocked(Transaction* transaction, int32_t sequenceId); diff --git a/services/surfaceflinger/TransactionCompletedThread.cpp b/services/surfaceflinger/TransactionCompletedThread.cpp index 5cf8eb1a1d..c519f8d647 100644 --- a/services/surfaceflinger/TransactionCompletedThread.cpp +++ b/services/surfaceflinger/TransactionCompletedThread.cpp @@ -75,14 +75,15 @@ void TransactionCompletedThread::run() { mThread = std::thread(&TransactionCompletedThread::threadMain, this); } -status_t TransactionCompletedThread::addCallback(const sp<ITransactionCompletedListener>& listener, - const std::vector<CallbackId>& callbackIds) { +status_t TransactionCompletedThread::startRegistration(const ListenerCallbacks& listenerCallbacks) { std::lock_guard lock(mMutex); if (!mRunning) { ALOGE("cannot add callback because the callback thread isn't running"); return BAD_VALUE; } + auto& [listener, callbackIds] = listenerCallbacks; + if (mCompletedTransactions.count(listener) == 0) { status_t err = IInterface::asBinder(listener)->linkToDeath(mDeathRecipient); if (err != NO_ERROR) { @@ -91,11 +92,41 @@ status_t TransactionCompletedThread::addCallback(const sp<ITransactionCompletedL } } + mRegisteringTransactions.insert(listenerCallbacks); + auto& transactionStatsDeque = mCompletedTransactions[listener]; transactionStatsDeque.emplace_back(callbackIds); + return NO_ERROR; } +status_t TransactionCompletedThread::endRegistration(const ListenerCallbacks& listenerCallbacks) { + std::lock_guard lock(mMutex); + if (!mRunning) { + ALOGE("cannot add callback because the callback thread isn't running"); + return BAD_VALUE; + } + + auto itr = mRegisteringTransactions.find(listenerCallbacks); + if (itr == mRegisteringTransactions.end()) { + ALOGE("cannot end a registration that does not exist"); + return BAD_VALUE; + } + + mRegisteringTransactions.erase(itr); + + return NO_ERROR; +} + +bool TransactionCompletedThread::isRegisteringTransaction( + const sp<ITransactionCompletedListener>& transactionListener, + const std::vector<CallbackId>& callbackIds) { + ListenerCallbacks listenerCallbacks(transactionListener, callbackIds); + + auto itr = mRegisteringTransactions.find(listenerCallbacks); + return itr != mRegisteringTransactions.end(); +} + status_t TransactionCompletedThread::registerPendingCallbackHandle( const sp<CallbackHandle>& handle) { std::lock_guard lock(mMutex); @@ -105,7 +136,7 @@ status_t TransactionCompletedThread::registerPendingCallbackHandle( } // If we can't find the transaction stats something has gone wrong. The client should call - // addCallback before trying to register a pending callback handle. + // startRegistration before trying to register a pending callback handle. TransactionStats* transactionStats; status_t err = findTransactionStats(handle->listener, handle->callbackIds, &transactionStats); if (err != NO_ERROR) { @@ -117,7 +148,7 @@ status_t TransactionCompletedThread::registerPendingCallbackHandle( return NO_ERROR; } -status_t TransactionCompletedThread::addPresentedCallbackHandles( +status_t TransactionCompletedThread::finalizePendingCallbackHandles( const std::deque<sp<CallbackHandle>>& handles) { std::lock_guard lock(mMutex); if (!mRunning) { @@ -158,7 +189,7 @@ status_t TransactionCompletedThread::addPresentedCallbackHandles( return NO_ERROR; } -status_t TransactionCompletedThread::addUnpresentedCallbackHandle( +status_t TransactionCompletedThread::registerUnpresentedCallbackHandle( const sp<CallbackHandle>& handle) { std::lock_guard lock(mMutex); if (!mRunning) { @@ -189,7 +220,7 @@ status_t TransactionCompletedThread::findTransactionStats( status_t TransactionCompletedThread::addCallbackHandle(const sp<CallbackHandle>& handle) { // If we can't find the transaction stats something has gone wrong. The client should call - // addCallback before trying to add a presnted callback handle. + // startRegistration before trying to add a callback handle. TransactionStats* transactionStats; status_t err = findTransactionStats(handle->listener, handle->callbackIds, &transactionStats); if (err != NO_ERROR) { @@ -197,8 +228,14 @@ status_t TransactionCompletedThread::addCallbackHandle(const sp<CallbackHandle>& } transactionStats->latchTime = handle->latchTime; - transactionStats->surfaceStats.emplace_back(handle->surfaceControl, handle->acquireTime, - handle->previousReleaseFence); + // If the layer has already been destroyed, don't add the SurfaceControl to the callback. + // The client side keeps a sp<> to the SurfaceControl so if the SurfaceControl has been + // destroyed the client side is dead and there won't be anyone to send the callback to. + sp<IBinder> surfaceControl = handle->surfaceControl.promote(); + if (surfaceControl) { + transactionStats->surfaceStats.emplace_back(surfaceControl, handle->acquireTime, + handle->previousReleaseFence); + } return NO_ERROR; } @@ -233,6 +270,13 @@ void TransactionCompletedThread::threadMain() { while (transactionStatsItr != transactionStatsDeque.end()) { auto& transactionStats = *transactionStatsItr; + // If this transaction is still registering, it is not safe to send a callback + // because there could be surface controls that haven't been added to + // transaction stats or mPendingTransactions. + if (isRegisteringTransaction(listener, transactionStats.callbackIds)) { + break; + } + // If we are still waiting on the callback handles for this transaction, stop // here because all transaction callbacks for the same listener must come in order auto pendingTransactions = mPendingTransactions.find(listener); diff --git a/services/surfaceflinger/TransactionCompletedThread.h b/services/surfaceflinger/TransactionCompletedThread.h index 21e2678701..e255e5090e 100644 --- a/services/surfaceflinger/TransactionCompletedThread.h +++ b/services/surfaceflinger/TransactionCompletedThread.h @@ -21,6 +21,7 @@ #include <mutex> #include <thread> #include <unordered_map> +#include <unordered_set> #include <android-base/thread_annotations.h> @@ -30,6 +31,12 @@ namespace android { +struct ITransactionCompletedListenerHash { + std::size_t operator()(const sp<ITransactionCompletedListener>& listener) const { + return std::hash<IBinder*>{}((listener) ? IInterface::asBinder(listener).get() : nullptr); + } +}; + struct CallbackIdsHash { // CallbackId vectors have several properties that let us get away with this simple hash. // 1) CallbackIds are never 0 so if something has gone wrong and our CallbackId vector is @@ -42,6 +49,22 @@ struct CallbackIdsHash { } }; +struct ListenerCallbacksHash { + std::size_t HashCombine(size_t value1, size_t value2) const { + return value1 ^ (value2 + 0x9e3779b9 + (value1 << 6) + (value1 >> 2)); + } + + std::size_t operator()(const ListenerCallbacks& listenerCallbacks) const { + struct ITransactionCompletedListenerHash listenerHasher; + struct CallbackIdsHash callbackIdsHasher; + + std::size_t listenerHash = listenerHasher(listenerCallbacks.transactionCompletedListener); + std::size_t callbackIdsHash = callbackIdsHasher(listenerCallbacks.callbackIds); + + return HashCombine(listenerHash, callbackIdsHash); + } +}; + class CallbackHandle : public RefBase { public: CallbackHandle(const sp<ITransactionCompletedListener>& transactionListener, @@ -49,7 +72,7 @@ public: sp<ITransactionCompletedListener> listener; std::vector<CallbackId> callbackIds; - sp<IBinder> surfaceControl; + wp<IBinder> surfaceControl; bool releasePreviousBuffer = false; sp<Fence> previousReleaseFence; @@ -64,10 +87,12 @@ public: void run(); // Adds listener and callbackIds in case there are no SurfaceControls that are supposed - // to be included in the callback. This functions should be call before attempting to add any - // callback handles. - status_t addCallback(const sp<ITransactionCompletedListener>& transactionListener, - const std::vector<CallbackId>& callbackIds); + // to be included in the callback. This functions should be call before attempting to register + // any callback handles. + status_t startRegistration(const ListenerCallbacks& listenerCallbacks); + // Ends the registration. After this is called, no more CallbackHandles will be registered. + // It is safe to send a callback if the Transaction doesn't have any Pending callback handles. + status_t endRegistration(const ListenerCallbacks& listenerCallbacks); // Informs the TransactionCompletedThread that there is a Transaction with a CallbackHandle // that needs to be latched and presented this frame. This function should be called once the @@ -76,11 +101,11 @@ public: // presented. status_t registerPendingCallbackHandle(const sp<CallbackHandle>& handle); // Notifies the TransactionCompletedThread that a pending CallbackHandle has been presented. - status_t addPresentedCallbackHandles(const std::deque<sp<CallbackHandle>>& handles); + status_t finalizePendingCallbackHandles(const std::deque<sp<CallbackHandle>>& handles); // Adds the Transaction CallbackHandle from a layer that does not need to be relatched and // presented this frame. - status_t addUnpresentedCallbackHandle(const sp<CallbackHandle>& handle); + status_t registerUnpresentedCallbackHandle(const sp<CallbackHandle>& handle); void addPresentFence(const sp<Fence>& presentFence); @@ -89,6 +114,9 @@ public: private: void threadMain(); + bool isRegisteringTransaction(const sp<ITransactionCompletedListener>& transactionListener, + const std::vector<CallbackId>& callbackIds) REQUIRES(mMutex); + status_t findTransactionStats(const sp<ITransactionCompletedListener>& listener, const std::vector<CallbackId>& callbackIds, TransactionStats** outTransactionStats) REQUIRES(mMutex); @@ -106,13 +134,6 @@ private: }; sp<ThreadDeathRecipient> mDeathRecipient; - struct ITransactionCompletedListenerHash { - std::size_t operator()(const sp<ITransactionCompletedListener>& listener) const { - return std::hash<IBinder*>{}((listener) ? IInterface::asBinder(listener).get() - : nullptr); - } - }; - // Protects the creation and destruction of mThread std::mutex mThreadMutex; @@ -121,11 +142,15 @@ private: std::mutex mMutex; std::condition_variable_any mConditionVariable; + std::unordered_set<ListenerCallbacks, ListenerCallbacksHash> mRegisteringTransactions + GUARDED_BY(mMutex); + std::unordered_map< sp<ITransactionCompletedListener>, std::unordered_map<std::vector<CallbackId>, uint32_t /*count*/, CallbackIdsHash>, ITransactionCompletedListenerHash> mPendingTransactions GUARDED_BY(mMutex); + std::unordered_map<sp<ITransactionCompletedListener>, std::deque<TransactionStats>, ITransactionCompletedListenerHash> mCompletedTransactions GUARDED_BY(mMutex); diff --git a/services/surfaceflinger/sysprop/SurfaceFlingerProperties.sysprop b/services/surfaceflinger/sysprop/SurfaceFlingerProperties.sysprop index 565df9a8f4..56ab4e3f33 100644 --- a/services/surfaceflinger/sysprop/SurfaceFlingerProperties.sysprop +++ b/services/surfaceflinger/sysprop/SurfaceFlingerProperties.sysprop @@ -323,6 +323,18 @@ prop { prop_name: "ro.surface_flinger.set_touch_timer_ms" } +# setDisplayPowerTimerMs indicates what is considered a timeout in milliseconds for Scheduler. +# This value is used by the Scheduler to trigger display power inactivity callbacks that will +# keep the display in peak refresh rate as long as display power is not in normal mode. +# Setting this property to 0 means there is no timer. +prop { + api_name: "set_display_power_timer_ms" + type: Integer + scope: System + access: Readonly + prop_name: "ro.surface_flinger.set_display_power_timer_ms" +} + # useSmart90ForVideo indicates whether Scheduler should detect content FPS, and try to adjust the # screen refresh rate based on that. prop { diff --git a/services/surfaceflinger/sysprop/api/system-current.txt b/services/surfaceflinger/sysprop/api/system-current.txt index 89323c2ad0..79854b36a2 100644 --- a/services/surfaceflinger/sysprop/api/system-current.txt +++ b/services/surfaceflinger/sysprop/api/system-current.txt @@ -18,6 +18,7 @@ package android.sysprop { method public static java.util.Optional<java.lang.Long> present_time_offset_from_vsync_ns(); method public static java.util.Optional<android.sysprop.SurfaceFlingerProperties.primary_display_orientation_values> primary_display_orientation(); method public static java.util.Optional<java.lang.Boolean> running_without_sync_framework(); + method public static java.util.Optional<java.lang.Integer> set_display_power_timer_ms(); method public static java.util.Optional<java.lang.Integer> set_idle_timer_ms(); method public static java.util.Optional<java.lang.Integer> set_touch_timer_ms(); method public static java.util.Optional<java.lang.Boolean> start_graphics_allocator_service(); diff --git a/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp b/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp index 5cc946aa79..26c6da95dd 100644 --- a/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp +++ b/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp @@ -43,14 +43,17 @@ constexpr uint32_t LAYER_UPDATE = INT_MAX - 2; constexpr uint32_t SIZE_UPDATE = 134; constexpr uint32_t STACK_UPDATE = 1; constexpr uint64_t DEFERRED_UPDATE = 0; +constexpr int32_t RELATIVE_Z = 42; constexpr float ALPHA_UPDATE = 0.29f; constexpr float CORNER_RADIUS_UPDATE = 0.2f; constexpr float POSITION_UPDATE = 121; const Rect CROP_UPDATE(16, 16, 32, 32); const String8 DISPLAY_NAME("SurfaceInterceptor Display Test"); -constexpr auto TEST_SURFACE_NAME = "BG Interceptor Test Surface"; -constexpr auto UNIQUE_TEST_SURFACE_NAME = "BG Interceptor Test Surface#0"; +constexpr auto TEST_BG_SURFACE_NAME = "BG Interceptor Test Surface"; +constexpr auto TEST_FG_SURFACE_NAME = "FG Interceptor Test Surface"; +constexpr auto UNIQUE_TEST_BG_SURFACE_NAME = "BG Interceptor Test Surface#0"; +constexpr auto UNIQUE_TEST_FG_SURFACE_NAME = "FG Interceptor Test Surface#0"; constexpr auto LAYER_NAME = "Layer Create and Delete Test"; constexpr auto UNIQUE_LAYER_NAME = "Layer Create and Delete Test#0"; @@ -136,12 +139,15 @@ protected: void TearDown() override { mComposerClient->dispose(); mBGSurfaceControl.clear(); + mFGSurfaceControl.clear(); mComposerClient.clear(); } sp<SurfaceComposerClient> mComposerClient; sp<SurfaceControl> mBGSurfaceControl; + sp<SurfaceControl> mFGSurfaceControl; int32_t mBGLayerId; + int32_t mFGLayerId; public: using TestTransactionAction = void (SurfaceInterceptorTest::*)(Transaction&); @@ -177,6 +183,10 @@ public: bool opaqueFlagUpdateFound(const SurfaceChange& change, bool foundOpaqueFlag); bool secureFlagUpdateFound(const SurfaceChange& change, bool foundSecureFlag); bool deferredTransactionUpdateFound(const SurfaceChange& change, bool foundDeferred); + bool reparentUpdateFound(const SurfaceChange& change, bool found); + bool relativeParentUpdateFound(const SurfaceChange& change, bool found); + bool detachChildrenUpdateFound(const SurfaceChange& change, bool found); + bool reparentChildrenUpdateFound(const SurfaceChange& change, bool found); bool surfaceUpdateFound(const Trace& trace, SurfaceChange::SurfaceChangeCase changeCase); // Find all of the updates in the single trace @@ -209,6 +219,10 @@ public: void opaqueFlagUpdate(Transaction&); void secureFlagUpdate(Transaction&); void deferredTransactionUpdate(Transaction&); + void reparentUpdate(Transaction&); + void relativeParentUpdate(Transaction&); + void detachChildrenUpdate(Transaction&); + void reparentChildrenUpdate(Transaction&); void surfaceCreation(Transaction&); void displayCreation(Transaction&); void displayDeletion(Transaction&); @@ -250,21 +264,30 @@ void SurfaceInterceptorTest::setupBackgroundSurface() { ssize_t displayHeight = info.h; // Background surface - mBGSurfaceControl = mComposerClient->createSurface( - String8(TEST_SURFACE_NAME), displayWidth, displayHeight, - PIXEL_FORMAT_RGBA_8888, 0); + mBGSurfaceControl = mComposerClient->createSurface(String8(TEST_BG_SURFACE_NAME), displayWidth, + displayHeight, PIXEL_FORMAT_RGBA_8888, 0); ASSERT_TRUE(mBGSurfaceControl != nullptr); ASSERT_TRUE(mBGSurfaceControl->isValid()); + // Foreground surface + mFGSurfaceControl = mComposerClient->createSurface(String8(TEST_FG_SURFACE_NAME), displayWidth, + displayHeight, PIXEL_FORMAT_RGBA_8888, 0); + ASSERT_TRUE(mFGSurfaceControl != nullptr); + ASSERT_TRUE(mFGSurfaceControl->isValid()); + Transaction t; t.setDisplayLayerStack(display, 0); - ASSERT_EQ(NO_ERROR, t.setLayer(mBGSurfaceControl, INT_MAX-3) - .show(mBGSurfaceControl) - .apply()); + ASSERT_EQ(NO_ERROR, + t.setLayer(mBGSurfaceControl, INT_MAX - 3) + .show(mBGSurfaceControl) + .setLayer(mFGSurfaceControl, INT_MAX - 3) + .show(mFGSurfaceControl) + .apply()); } void SurfaceInterceptorTest::preProcessTrace(const Trace& trace) { - mBGLayerId = getSurfaceId(trace, UNIQUE_TEST_SURFACE_NAME); + mBGLayerId = getSurfaceId(trace, UNIQUE_TEST_BG_SURFACE_NAME); + mFGLayerId = getSurfaceId(trace, UNIQUE_TEST_FG_SURFACE_NAME); } void SurfaceInterceptorTest::captureTest(TestTransactionAction action, @@ -364,6 +387,22 @@ void SurfaceInterceptorTest::deferredTransactionUpdate(Transaction& t) { DEFERRED_UPDATE); } +void SurfaceInterceptorTest::reparentUpdate(Transaction& t) { + t.reparent(mBGSurfaceControl, mFGSurfaceControl->getHandle()); +} + +void SurfaceInterceptorTest::relativeParentUpdate(Transaction& t) { + t.setRelativeLayer(mBGSurfaceControl, mFGSurfaceControl->getHandle(), RELATIVE_Z); +} + +void SurfaceInterceptorTest::detachChildrenUpdate(Transaction& t) { + t.detachChildren(mBGSurfaceControl); +} + +void SurfaceInterceptorTest::reparentChildrenUpdate(Transaction& t) { + t.reparentChildren(mBGSurfaceControl, mFGSurfaceControl->getHandle()); +} + void SurfaceInterceptorTest::displayCreation(Transaction&) { sp<IBinder> testDisplay = SurfaceComposerClient::createDisplay(DISPLAY_NAME, true); SurfaceComposerClient::destroyDisplay(testDisplay); @@ -389,6 +428,10 @@ void SurfaceInterceptorTest::runAllUpdates() { runInTransaction(&SurfaceInterceptorTest::opaqueFlagUpdate); runInTransaction(&SurfaceInterceptorTest::secureFlagUpdate); runInTransaction(&SurfaceInterceptorTest::deferredTransactionUpdate); + runInTransaction(&SurfaceInterceptorTest::reparentUpdate); + runInTransaction(&SurfaceInterceptorTest::reparentChildrenUpdate); + runInTransaction(&SurfaceInterceptorTest::detachChildrenUpdate); + runInTransaction(&SurfaceInterceptorTest::relativeParentUpdate); } void SurfaceInterceptorTest::surfaceCreation(Transaction&) { @@ -569,6 +612,46 @@ bool SurfaceInterceptorTest::deferredTransactionUpdateFound(const SurfaceChange& return foundDeferred; } +bool SurfaceInterceptorTest::reparentUpdateFound(const SurfaceChange& change, bool found) { + bool hasId(change.reparent().parent_id() == mFGLayerId); + if (hasId && !found) { + found = true; + } else if (hasId && found) { + []() { FAIL(); }(); + } + return found; +} + +bool SurfaceInterceptorTest::relativeParentUpdateFound(const SurfaceChange& change, bool found) { + bool hasId(change.relative_parent().relative_parent_id() == mFGLayerId); + if (hasId && !found) { + found = true; + } else if (hasId && found) { + []() { FAIL(); }(); + } + return found; +} + +bool SurfaceInterceptorTest::detachChildrenUpdateFound(const SurfaceChange& change, bool found) { + bool detachChildren(change.detach_children().detach_children()); + if (detachChildren && !found) { + found = true; + } else if (detachChildren && found) { + []() { FAIL(); }(); + } + return found; +} + +bool SurfaceInterceptorTest::reparentChildrenUpdateFound(const SurfaceChange& change, bool found) { + bool hasId(change.reparent_children().parent_id() == mFGLayerId); + if (hasId && !found) { + found = true; + } else if (hasId && found) { + []() { FAIL(); }(); + } + return found; +} + bool SurfaceInterceptorTest::surfaceUpdateFound(const Trace& trace, SurfaceChange::SurfaceChangeCase changeCase) { bool foundUpdate = false; @@ -620,6 +703,18 @@ bool SurfaceInterceptorTest::surfaceUpdateFound(const Trace& trace, case SurfaceChange::SurfaceChangeCase::kDeferredTransaction: foundUpdate = deferredTransactionUpdateFound(change, foundUpdate); break; + case SurfaceChange::SurfaceChangeCase::kReparent: + foundUpdate = reparentUpdateFound(change, foundUpdate); + break; + case SurfaceChange::SurfaceChangeCase::kReparentChildren: + foundUpdate = reparentChildrenUpdateFound(change, foundUpdate); + break; + case SurfaceChange::SurfaceChangeCase::kRelativeParent: + foundUpdate = relativeParentUpdateFound(change, foundUpdate); + break; + case SurfaceChange::SurfaceChangeCase::kDetachChildren: + foundUpdate = detachChildrenUpdateFound(change, foundUpdate); + break; case SurfaceChange::SurfaceChangeCase::SURFACECHANGE_NOT_SET: break; } @@ -644,6 +739,10 @@ void SurfaceInterceptorTest::assertAllUpdatesFound(const Trace& trace) { ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kOpaqueFlag)); ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kSecureFlag)); ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kDeferredTransaction)); + ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kReparent)); + ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kReparentChildren)); + ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kRelativeParent)); + ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kDetachChildren)); } bool SurfaceInterceptorTest::surfaceCreationFound(const Increment& increment, bool foundSurface) { @@ -798,6 +897,26 @@ TEST_F(SurfaceInterceptorTest, InterceptDeferredTransactionUpdateWorks) { SurfaceChange::SurfaceChangeCase::kDeferredTransaction); } +TEST_F(SurfaceInterceptorTest, InterceptReparentUpdateWorks) { + captureTest(&SurfaceInterceptorTest::reparentUpdate, + SurfaceChange::SurfaceChangeCase::kReparent); +} + +TEST_F(SurfaceInterceptorTest, InterceptReparentChildrenUpdateWorks) { + captureTest(&SurfaceInterceptorTest::reparentChildrenUpdate, + SurfaceChange::SurfaceChangeCase::kReparentChildren); +} + +TEST_F(SurfaceInterceptorTest, InterceptRelativeParentUpdateWorks) { + captureTest(&SurfaceInterceptorTest::relativeParentUpdate, + SurfaceChange::SurfaceChangeCase::kRelativeParent); +} + +TEST_F(SurfaceInterceptorTest, InterceptDetachChildrenUpdateWorks) { + captureTest(&SurfaceInterceptorTest::detachChildrenUpdate, + SurfaceChange::SurfaceChangeCase::kDetachChildren); +} + TEST_F(SurfaceInterceptorTest, InterceptAllUpdatesWorks) { captureTest(&SurfaceInterceptorTest::runAllUpdates, &SurfaceInterceptorTest::assertAllUpdatesFound); diff --git a/services/surfaceflinger/tests/Transaction_test.cpp b/services/surfaceflinger/tests/Transaction_test.cpp index d5f65348d8..aed7b40872 100644 --- a/services/surfaceflinger/tests/Transaction_test.cpp +++ b/services/surfaceflinger/tests/Transaction_test.cpp @@ -4427,6 +4427,30 @@ TEST_F(LayerUpdateTest, MergingTransactions) { } } +TEST_F(LayerUpdateTest, MergingTransactionFlags) { + Transaction().hide(mFGSurfaceControl).apply(); + std::unique_ptr<ScreenCapture> sc; + { + SCOPED_TRACE("before merge"); + ScreenCapture::captureScreen(&sc); + sc->expectBGColor(0, 12); + sc->expectBGColor(75, 75); + sc->expectBGColor(145, 145); + } + + Transaction t1, t2; + t1.show(mFGSurfaceControl); + t2.setFlags(mFGSurfaceControl, 0 /* flags */, layer_state_t::eLayerSecure /* mask */); + t1.merge(std::move(t2)); + t1.apply(); + + { + SCOPED_TRACE("after merge"); + ScreenCapture::captureScreen(&sc); + sc->expectFGColor(75, 75); + } +} + class ChildLayerTest : public LayerUpdateTest { protected: void SetUp() override { diff --git a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp index 7ec90660ce..8e7440c2e3 100644 --- a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp +++ b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp @@ -27,6 +27,15 @@ protected: static constexpr float MIN_REFRESH_RATE = 30.f; static constexpr float MAX_REFRESH_RATE = 90.f; + static constexpr auto RELEVANT_FRAME_THRESHOLD = 90u; + static constexpr uint64_t THIRTY_FPS_INTERVAL = 33'333'333; + + void forceRelevancy(const std::unique_ptr<LayerHistory::LayerHandle>& testLayer) { + mLayerHistory->setVisibility(testLayer, true); + for (auto i = 0u; i < RELEVANT_FRAME_THRESHOLD; i++) { + mLayerHistory->insert(testLayer, 0, false /*isHDR*/); + } + }; }; LayerHistoryTest::LayerHistoryTest() { @@ -39,24 +48,18 @@ TEST_F(LayerHistoryTest, oneLayer) { std::unique_ptr<LayerHistory::LayerHandle> testLayer = mLayerHistory->createLayer("TestLayer", MIN_REFRESH_RATE, MAX_REFRESH_RATE); mLayerHistory->setVisibility(testLayer, true); + for (auto i = 0u; i < RELEVANT_FRAME_THRESHOLD; i++) { + EXPECT_FLOAT_EQ(0.f, mLayerHistory->getDesiredRefreshRateAndHDR().first); + mLayerHistory->insert(testLayer, 0, false /*isHDR*/); + } - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - EXPECT_FLOAT_EQ(0.f, mLayerHistory->getDesiredRefreshRateAndHDR().first); - - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - // This is still 0, because the layer is not considered recently active if it - // has been present in less than 10 frames. - EXPECT_FLOAT_EQ(0.f, mLayerHistory->getDesiredRefreshRateAndHDR().first); - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - mLayerHistory->insert(testLayer, 0, false /*isHDR*/); - // This should be MAX_REFRESH_RATE as we have more than 10 samples - EXPECT_FLOAT_EQ(MAX_REFRESH_RATE, mLayerHistory->getDesiredRefreshRateAndHDR().first); + // Add a few more. This time we should get MAX refresh rate as the layer + // becomes relevant + static constexpr auto A_FEW = 10; + for (auto i = 0u; i < A_FEW; i++) { + EXPECT_FLOAT_EQ(MAX_REFRESH_RATE, mLayerHistory->getDesiredRefreshRateAndHDR().first); + mLayerHistory->insert(testLayer, 0, false /*isHDR*/); + } } TEST_F(LayerHistoryTest, oneHDRLayer) { @@ -79,8 +82,9 @@ TEST_F(LayerHistoryTest, explicitTimestamp) { mLayerHistory->setVisibility(test30FpsLayer, true); nsecs_t startTime = systemTime(); - for (int i = 0; i < 31; i++) { - mLayerHistory->insert(test30FpsLayer, startTime + (i * 33333333), false /*isHDR*/); + for (int i = 0; i < RELEVANT_FRAME_THRESHOLD; i++) { + mLayerHistory->insert(test30FpsLayer, startTime + (i * THIRTY_FPS_INTERVAL), + false /*isHDR*/); } EXPECT_FLOAT_EQ(30.f, mLayerHistory->getDesiredRefreshRateAndHDR().first); @@ -98,19 +102,21 @@ TEST_F(LayerHistoryTest, multipleLayers) { mLayerHistory->setVisibility(testLayer2, true); nsecs_t startTime = systemTime(); - for (int i = 0; i < 10; i++) { + for (int i = 0; i < RELEVANT_FRAME_THRESHOLD; i++) { mLayerHistory->insert(testLayer, 0, false /*isHDR*/); } EXPECT_FLOAT_EQ(MAX_REFRESH_RATE, mLayerHistory->getDesiredRefreshRateAndHDR().first); startTime = systemTime(); - for (int i = 0; i < 10; i++) { - mLayerHistory->insert(test30FpsLayer, startTime + (i * 33333333), false /*isHDR*/); + for (int i = 0; i < RELEVANT_FRAME_THRESHOLD; i++) { + mLayerHistory->insert(test30FpsLayer, startTime + (i * THIRTY_FPS_INTERVAL), + false /*isHDR*/); } EXPECT_FLOAT_EQ(MAX_REFRESH_RATE, mLayerHistory->getDesiredRefreshRateAndHDR().first); - for (int i = 10; i < 30; i++) { - mLayerHistory->insert(test30FpsLayer, startTime + (i * 33333333), false /*isHDR*/); + for (int i = 10; i < RELEVANT_FRAME_THRESHOLD; i++) { + mLayerHistory->insert(test30FpsLayer, startTime + (i * THIRTY_FPS_INTERVAL), + false /*isHDR*/); } EXPECT_FLOAT_EQ(MAX_REFRESH_RATE, mLayerHistory->getDesiredRefreshRateAndHDR().first); @@ -122,8 +128,10 @@ TEST_F(LayerHistoryTest, multipleLayers) { EXPECT_FLOAT_EQ(MAX_REFRESH_RATE, mLayerHistory->getDesiredRefreshRateAndHDR().first); // After 1200 ms frames become obsolete. std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - // Insert the 31st frame. - mLayerHistory->insert(test30FpsLayer, startTime + (30 * 33333333), false /*isHDR*/); + + mLayerHistory->insert(test30FpsLayer, + startTime + (RELEVANT_FRAME_THRESHOLD * THIRTY_FPS_INTERVAL), + false /*isHDR*/); EXPECT_FLOAT_EQ(30.f, mLayerHistory->getDesiredRefreshRateAndHDR().first); } diff --git a/vulkan/README.md b/vulkan/README.md index 9fba7281fd..0f660977f9 100644 --- a/vulkan/README.md +++ b/vulkan/README.md @@ -10,19 +10,8 @@ Use "clang-format -style=file" to format all C/C++ code, except code imported ve ## Code Generation -We generate several parts of the loader and tools from a Vulkan API description file, stored in `api/vulkan.api`. Code generation must be done manually because the generator tools aren't part of the platform toolchain (yet?). Files named `foo_gen.*` are generated from the API file and a template file named `foo.tmpl`. +We generate several parts of the loader and tools driectly from the Vulkan Registry (external/vulkan-headers/registry/vk.xml). Code generation must be done manually because the generator is not part of the platform toolchain (yet?). Files named `foo_gen.*` are generated by the code generator. To run the generator: - -### One-time setup -- Install [golang](https://golang.org/), if you don't have it already. -- Create a directory (e.g. `$HOME/lib/go`) for local go sources and binaries and add it to `$GOPATH`. -- `$ git clone https://android.googlesource.com/platform/tools/gpu $GOPATH/src/android.googlesource.com/platform/tools/gpu` -- `$ go get android.googlesource.com/platform/tools/gpu/api/...` -- You should now have `$GOPATH/bin/apic`. You might want to add `$GOPATH/bin` to your `$PATH`. - -### Generating code -To generate `libvulkan/*_gen.*`, -- `$ cd libvulkan` -- `$ apic template ../api/vulkan.api code-generator.tmpl` -Similar for `nulldrv/null_driver_gen.*`. +- Install Python3 (if not already installed) +- `$ ./<path to>/frameworks/native/vulkan/scripts/code_generator.py` diff --git a/vulkan/api/platform.api b/vulkan/api/platform.api deleted file mode 100644 index a7c4c30b5e..0000000000 --- a/vulkan/api/platform.api +++ /dev/null @@ -1,61 +0,0 @@ -// Copyright (c) 2015 The Khronos Group Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and/or associated documentation files (the -// "Materials"), to deal in the Materials without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Materials, and to -// permit persons to whom the Materials are furnished to do so, subject to -// the following conditions: -// -// The above copyright notice and this permission notice shall be included -// in all copies or substantial portions of the Materials. -// -// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. - -// Platform types, as defined or included in vk_platform.h - -type u64 size_t - -// VK_USE_PLATFORM_XLIB_KHR -@internal class Display {} -@internal class Window {} -@internal type u64 VisualID - -// VK_USE_PLATFORM_XCB_KHR -@internal class xcb_connection_t {} -@internal type u32 xcb_window_t -@internal type u32 xcb_visualid_t - -// VK_USE_PLATFORM_WAYLAND_KHR -@internal class wl_display {} -@internal class wl_surface {} - -// VK_USE_PLATFORM_MIR_KHR -@internal class MirConnection {} -@internal class MirSurface {} - -// VK_USE_PLATFORM_ANDROID_KHR -@internal class ANativeWindow {} -@internal class AHardwareBuffer {} -@internal type void* buffer_handle_t - -// VK_USE_PLATFORM_WIN32_KHR -@internal type void* HINSTANCE -@internal type void* HWND -@internal type void* HANDLE -@internal type u32 DWORD -@internal type u16* LPCWSTR -@internal class SECURITY_ATTRIBUTES {} - -// VK_USE_PLATFORM_XLIB_XRANDR_EXT -@internal type u64 RROutput - -// VK_USE_PLATFORM_FUCHSIA -@internal type u32 zx_handle_t
\ No newline at end of file diff --git a/vulkan/api/templates/vulkan_common.tmpl b/vulkan/api/templates/vulkan_common.tmpl deleted file mode 100644 index f694c56238..0000000000 --- a/vulkan/api/templates/vulkan_common.tmpl +++ /dev/null @@ -1,223 +0,0 @@ -{{$clang_style := "{BasedOnStyle: Google, AccessModifierOffset: -4, ColumnLimit: 200, ContinuationIndentWidth: 8, IndentWidth: 4, AlignOperands: true, CommentPragmas: '.*'}"}} -{{Global "clang-format" (Strings "clang-format" "-style" $clang_style)}} - - -{{/* -------------------------------------------------------------------------------- - Emits the C translation for the specified type. -------------------------------------------------------------------------------- -*/}} -{{define "Type.Class" }}{{if GetAnnotation $.Type "internal"}}struct {{end}}{{Macro "StructName" $.Type}}{{end}} -{{define "Type.Pseudonym" }}{{$.Type.Name}}{{end}} -{{define "Type.Enum" }}{{$.Type.Name}}{{end}} -{{define "Type.StaticArray"}}{{Node "Type" $.Type.ValueType}}{{end}} -{{define "Type.Pointer" }}{{if $.Type.Const}}{{Node "ConstType" $.Type.To}}{{else}}{{Node "Type" $.Type.To}}{{end}}*{{end}} -{{define "Type.Slice" }}{{Log "%T %+v" $.Node $.Node}}{{Node "Type" $.Type.To}}*{{end}} -{{define "Type#bool" }}bool{{end}} -{{define "Type#int" }}int{{end}} -{{define "Type#uint" }}unsigned int{{end}} -{{define "Type#s8" }}int8_t{{end}} -{{define "Type#u8" }}uint8_t{{end}} -{{define "Type#s16" }}int16_t{{end}} -{{define "Type#u16" }}uint16_t{{end}} -{{define "Type#s32" }}int32_t{{end}} -{{define "Type#u32" }}uint32_t{{end}} -{{define "Type#f32" }}float{{end}} -{{define "Type#s64" }}int64_t{{end}} -{{define "Type#u64" }}uint64_t{{end}} -{{define "Type#f64" }}double{{end}} -{{define "Type#void" }}void{{end}} -{{define "Type#char" }}char{{end}} - -{{define "ConstType_Default"}}const {{Node "Type" $.Type}}{{end}} -{{define "ConstType.Pointer"}}{{Node "Type" $.Type}} const{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the C translation for the specified documentation block (string array). -------------------------------------------------------------------------------- -*/}} -{{define "Docs"}} - {{if $}}// {{$ | JoinWith "\n// "}}{{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the name of a bitfield entry. -------------------------------------------------------------------------------- -*/}} -{{define "BitfieldEntryName"}} - {{AssertType $ "EnumEntry"}} - - {{Macro "EnumEntry" $}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the name of an enum type. -------------------------------------------------------------------------------- -*/}} -{{define "EnumName"}}{{AssertType $ "Enum"}}{{$.Name}}{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the name of an enum entry. -------------------------------------------------------------------------------- -*/}} -{{define "EnumEntry"}} - {{AssertType $.Owner "Enum"}} - {{AssertType $.Name "string"}} - - {{$.Name}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the name of the first entry of an enum. -------------------------------------------------------------------------------- -*/}} -{{define "EnumFirstEntry"}} - {{AssertType $ "Enum"}} - - {{range $i, $e := $.Entries}} - {{if not $i}}{{$e.Name}}{{end}} - {{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the name of the last entry of an enum. -------------------------------------------------------------------------------- -*/}}{{define "EnumLastEntry"}} - {{AssertType $ "Enum"}} - - {{range $i, $e := $.Entries}} - {{if not (HasMore $i $.Entries)}}{{$e.Name}}{{end}} - {{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the name of a struct (class) type. -------------------------------------------------------------------------------- -*/}} -{{define "StructName"}}{{AssertType $ "Class"}}{{$.Name}}{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the name of a function. -------------------------------------------------------------------------------- -*/}} -{{define "FunctionName"}}{{AssertType $ "Function"}}{{$.Name}}{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the fixed-size-array postfix for pseudonym types annotated with @array -------------------------------------------------------------------------------- -*/}} -{{define "ArrayPostfix"}}{{Node "ArrayPostfix" $}}{{end}} -{{define "ArrayPostfix.StaticArray"}}[{{$.Type.Size}}]{{end}} -{{define "ArrayPostfix_Default"}}{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a C type and name for the given parameter -------------------------------------------------------------------------------- -*/}} -{{define "Parameter"}} - {{AssertType $ "Parameter"}} - - {{if GetAnnotation $ "readonly"}}const {{end}}{{Macro "ParameterType" $}} {{$.Name}}{{Macro "ArrayPostfix" $}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a C name for the given parameter -------------------------------------------------------------------------------- -*/}} -{{define "ParameterName"}} - {{AssertType $ "Parameter"}} - - {{$.Name}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a C type for the given parameter -------------------------------------------------------------------------------- -*/}} -{{define "ParameterType"}}{{AssertType $ "Parameter"}}{{Node "Type" $}}{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a comma-separated list of C type-name paired parameters for the given - command. -------------------------------------------------------------------------------- -*/}} -{{define "Parameters"}} - {{AssertType $ "Function"}} - - {{ForEach $.CallParameters "Parameter" | JoinWith ", "}} - {{if not $.CallParameters}}void{{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits the C function pointer name for the specified command. -------------------------------------------------------------------------------- -*/}} -{{define "FunctionPtrName"}} - {{AssertType $ "Function"}} - - PFN_{{$.Name}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Parses const variables as text Globals. -------------------------------------------------------------------------------- -*/}} -{{define "DefineGlobals"}} - {{AssertType $ "API"}} - - {{range $d := $.Definitions}} - {{Global $d.Name $d.Expression}} - {{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Given a function, return "Global", "Instance", or "Device" depending on which - dispatch table the function belongs to. -------------------------------------------------------------------------------- -*/}} -{{define "Vtbl#VkInstance" }}Instance{{end}} -{{define "Vtbl#VkPhysicalDevice"}}Instance{{end}} -{{define "Vtbl#VkDevice" }}Device{{end}} -{{define "Vtbl#VkQueue" }}Device{{end}} -{{define "Vtbl#VkCommandBuffer" }}Device{{end}} -{{define "Vtbl_Default" }}Global{{end}} -{{define "Vtbl"}} - {{AssertType $ "Function"}} - - {{if gt (len $.CallParameters) 0}} - {{Node "Vtbl" (index $.CallParameters 0)}} - {{else}}Global - {{end}} -{{end}} diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api deleted file mode 100644 index 76503c8c17..0000000000 --- a/vulkan/api/vulkan.api +++ /dev/null @@ -1,12163 +0,0 @@ -// Copyright (c) 2015 The Khronos Group Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and/or associated documentation files (the -// "Materials"), to deal in the Materials without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Materials, and to -// permit persons to whom the Materials are furnished to do so, subject to -// the following conditions: -// -// The above copyright notice and this permission notice shall be included -// in all copies or substantial portions of the Materials. -// -// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. - -import platform "platform.api" - -/////////////// -// Constants // -/////////////// - -// API version (major.minor.patch) -define VERSION_MAJOR 1 -define VERSION_MINOR 1 -define VERSION_PATCH 96 - -// API limits -define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 -define VK_UUID_SIZE 16 -define VK_MAX_EXTENSION_NAME_SIZE 256 -define VK_MAX_DESCRIPTION_SIZE 256 -define VK_MAX_MEMORY_TYPES 32 -define VK_MAX_MEMORY_HEAPS 16 /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types. -@vulkan1_1 -define VK_MAX_DEVICE_GROUP_SIZE 32 -@vulkan1_1 -define VK_LUID_SIZE 8 -@vulkan1_1 -define VK_QUEUE_FAMILY_EXTERNAL -2 -@extension("VK_EXT_queue_family_foreign") -define VK_QUEUE_FAMILY_FOREIGN_EXT -3 -@extension("VK_MAX_DRIVER_NAME_SIZE_KHR") // 197 -define VK_MAX_DRIVER_NAME_SIZE_KHR 256 -@extension("VK_MAX_DRIVER_NAME_SIZE_KHR") // 197 -define VK_MAX_DRIVER_INFO_SIZE_KHR 256 - -// API keywords -define VK_TRUE 1 -define VK_FALSE 0 - -// API keyword, but needs special handling by some templates -define NULL_HANDLE 0 - -// 1 -@extension("VK_KHR_surface") define VK_KHR_SURFACE_SPEC_VERSION 25 -@extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" - -// 2 -@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 -@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" - -// 3 -@extension("VK_KHR_display") define VK_KHR_DISPLAY_SPEC_VERSION 21 -@extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" - -// 4 -@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 -@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" - -// 5 -@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 -@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NAME "VK_KHR_xlib_surface" - -// 6 -@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 -@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NAME "VK_KHR_xcb_surface" - -// 7 -@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 -@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NAME "VK_KHR_wayland_surface" - -// 8 - VK_KHR_mir_surface removed - -// 9 -@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 -@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NAME "VK_KHR_android_surface" - -// 10 -@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 -@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NAME "VK_KHR_win32_surface" - -// 11 -@extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 8 -@extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_NAME "VK_ANDROID_native_buffer" - -// 12 -@extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9 -@extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_NAME "VK_EXT_debug_report" - -// 13 -@extension("VK_NV_glsl_shader") define VK_NV_GLSL_SHADER_SPEC_VERSION 1 -@extension("VK_NV_glsl_shader") define VK_NV_GLSL_SHADER_NAME "VK_NV_glsl_shader" - -// 14 -@extension("VK_EXT_depth_range_unrestricted") define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 -@extension("VK_EXT_depth_range_unrestricted") define VK_EXT_DEPTH_RANGE_UNRESTRICTED_NAME "VK_EXT_depth_range_unrestricted" - -// 15 -@extension("VK_KHR_sampler_mirror_clamp_to_edge") define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 -@extension("VK_KHR_sampler_mirror_clamp_to_edge") define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_NAME "VK_KHR_sampler_mirror_clamp_to_edge" - -// 16 -@extension("VK_IMG_filter_cubic") define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 -@extension("VK_IMG_filter_cubic") define VK_IMG_FILTER_CUBIC_NAME "VK_IMG_filter_cubic" - -// 19 -@extension("VK_AMD_rasterization_order") define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 -@extension("VK_AMD_rasterization_order") define VK_AMD_RASTERIZATION_ORDER_NAME "VK_AMD_rasterization_order" - -// 21 -@extension("VK_AMD_shader_trinary_minmax") define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 -@extension("VK_AMD_shader_trinary_minmax") define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" - -// 22 -@extension("VK_AMD_shader_explicit_vertex_parameter") define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 -@extension("VK_AMD_shader_explicit_vertex_parameter") define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" - -// 23 -@extension("VK_EXT_debug_marker") define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 -@extension("VK_EXT_debug_marker") define VK_EXT_DEBUG_MARKER_NAME "VK_EXT_debug_marker" - -// 26 -@extension("VK_AMD_gcn_shader") define VK_AMD_GCN_SHADER_SPEC_VERSION 1 -@extension("VK_AMD_gcn_shader") define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" - -// 27 -@extension("VK_NV_dedicated_allocation") define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 -@extension("VK_NV_dedicated_allocation") define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" - -// 28 -@extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 -@extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" - -// 29 -@extension("VK_EXT_transform_feedback") define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1 -@extension("VK_EXT_transform_feedback") define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback" - -// 34 -@extension("VK_AMD_draw_indirect_count") define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 -@extension("VK_AMD_draw_indirect_count") define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" - -// 36 -@extension("VK_AMD_negative_viewport_height") define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 -@extension("VK_AMD_negative_viewport_height") define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" - -// 37 -@extension("VK_AMD_gpu_shader_half_float") define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 -@extension("VK_AMD_gpu_shader_half_float") define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" - -// 38 -@extension("VK_AMD_shader_ballot") define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 -@extension("VK_AMD_shader_ballot") define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" - -// 42 -@extension("VK_AMD_texture_gather_bias_lod") define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 -@extension("VK_AMD_texture_gather_bias_lod") define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" - -// 43 -@extension("VK_AMD_shader_info") define VK_AMD_SHADER_INFO_SPEC_VERSION 1 -@extension("VK_AMD_shader_info") define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" - -// 47 -@extension("VK_AMD_shader_image_load_store_lod") define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 -@extension("VK_AMD_shader_image_load_store_lod") define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" - -// 51 -@extension("VK_NV_corner_sampled_image") define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2 -@extension("VK_NV_corner_sampled_image") define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image" - -// 54 -@extension("VK_KHR_multiview") define VK_KHR_MULTIVIEW_SPEC_VERSION 1 -@extension("VK_KHR_multiview") define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" - -// 56 -@extension("VK_NV_external_memory_capabilities") define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -@extension("VK_NV_external_memory_capabilities") define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" - -// 57 -@extension("VK_NV_external_memory") define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 -@extension("VK_NV_external_memory") define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" - -// 58 -@extension("VK_NV_external_memory_win32") define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 -@extension("VK_NV_external_memory_win32") define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" - -// 59 -@extension("VK_NV_win32_keyed_mutex") define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 -@extension("VK_NV_win32_keyed_mutex") define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" - -// 60 -@extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 -@extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" - -// 61 -@extension("VK_KHR_device_group") define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3 -@extension("VK_KHR_device_group") define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" - -// 62 -@extension("VK_EXT_validation_flags") define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 -@extension("VK_EXT_validation_flags") define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" - -// 63 -@extension("VK_NN_vi_surface") define VK_NN_VI_SURFACE_SPEC_VERSION 1 -@extension("VK_NN_vi_surface") define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" - -// 64 -@extension("VK_KHR_shader_draw_parameters") define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 -@extension("VK_KHR_shader_draw_parameters") define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" - -// 65 -@extension("VK_EXT_shader_subgroup_ballot") define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 -@extension("VK_EXT_shader_subgroup_ballot") define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" - -// 66 -@extension("VK_EXT_shader_subgroup_vote") define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 -@extension("VK_EXT_shader_subgroup_vote") define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" - -// 68 -@extension("VK_EXT_astc_decode_mode") define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 -@extension("VK_EXT_astc_decode_mode") define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" - -// 70 -@extension("VK_KHR_maintenance1") define VK_KHR_MAINTENANCE1_SPEC_VERSION 2 -@extension("VK_KHR_maintenance1") define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" - -// 71 -@extension("VK_KHR_device_group_creation") define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 -@extension("VK_KHR_device_group_creation") define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" - -// 72 -@extension("VK_KHR_external_memory_capabilities") define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -@extension("VK_KHR_external_memory_capabilities") define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" - -// 73 -@extension("VK_KHR_external_memory") define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 -@extension("VK_KHR_external_memory") define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" - -// 74 -@extension("VK_KHR_external_memory_win32") define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 -@extension("VK_KHR_external_memory_win32") define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" - -// 75 -@extension("VK_KHR_external_memory_fd") define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 -@extension("VK_KHR_external_memory_fd") define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" - -// 76 -@extension("VK_KHR_win32_keyed_mutex") define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 -@extension("VK_KHR_win32_keyed_mutex") define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" - -// 77 -@extension("VK_KHR_external_semaphore_capabilities") define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 -@extension("VK_KHR_external_semaphore_capabilities") define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" - -// 78 -@extension("VK_KHR_external_semaphore") define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 -@extension("VK_KHR_external_semaphore") define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" - -// 79 -@extension("VK_KHR_external_semaphore_win32") define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 -@extension("VK_KHR_external_semaphore_win32") define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" - -// 80 -@extension("VK_KHR_external_semaphore_fd") define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 -@extension("VK_KHR_external_semaphore_fd") define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" - -// 81 -@extension("VK_KHR_push_descriptor") define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 -@extension("VK_KHR_push_descriptor") define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" - -// 82 -@extension("VK_EXT_conditional_rendering") define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1 -@extension("VK_EXT_conditional_rendering") define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" - -// 83 -@extension("VK_KHR_shader_float16_int8") define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1 -@extension("VK_KHR_shader_float16_int8") define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8" - -// 84 -@extension("VK_KHR_16bit_storage") define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 -@extension("VK_KHR_16bit_storage") define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" - -// 85 -@extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 -@extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" - -// 86 -@extension("VK_KHR_descriptor_update_template") define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 -@extension("VK_KHR_descriptor_update_template") define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" - -// 87 -@extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 -@extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands" - -// 88 -@extension("VK_NV_clip_space_w_scaling") define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 -@extension("VK_NV_clip_space_w_scaling") define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" - -// 89 -@extension("VK_EXT_direct_mode_display") define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 -@extension("VK_EXT_direct_mode_display") define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" - -// 90 -@extension("VK_EXT_acquire_xlib_display") define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 -@extension("VK_EXT_acquire_xlib_display") define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" - -// 91 -@extension("VK_EXT_display_surface_counter") define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 -@extension("VK_EXT_display_surface_counter") define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" - -// 92 -@extension("VK_EXT_display_control") define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 -@extension("VK_EXT_display_control") define VK_EXT_DISPLAY_CONTROL_COUNTER_EXTENSION_NAME "VK_EXT_display_control" - -// 93 -@extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 -@extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" - -// 95 -@extension("VK_NV_sample_mask_override_coverage") define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 -@extension("VK_NV_sample_mask_override_coverage") define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" - -// 96 -@extension("VK_NV_geometry_shader_passthrough") define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 -@extension("VK_NV_geometry_shader_passthrough") define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" - -// 97 -@extension("VK_NV_viewport_array2") define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1 -@extension("VK_NV_viewport_array2") define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2" - -// 98 -@extension("VK_NVX_multiview_per_view_attributes") define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 -@extension("VK_NVX_multiview_per_view_attributes") define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" - -// 99 -@extension("VK_NV_viewport_swizzle") define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 -@extension("VK_NV_viewport_swizzle") define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" - -// 100 -@extension("VK_EXT_discard_rectangles") define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 -@extension("VK_EXT_discard_rectangles") define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" - -// 102 -@extension("VK_EXT_conservative_rasterization") define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 -@extension("VK_EXT_conservative_rasterization") define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" - -// 105 -@extension("VK_EXT_swapchain_colorspace") define VK_EXT_SWAPCHAIN_COLORSPACE_SPEC_VERSION 3 -@extension("VK_EXT_swapchain_colorspace") define VK_EXT_SWAPCHAIN_COLORSPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" - -// 106 -@extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_SPEC_VERSION 1 -@extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" - -// 110 -@extension("VK_KHR_create_renderpass2") define VK_KHR_CREATE_RENDERPASS2_SPEC_VERSION 1 -@extension("VK_KHR_create_renderpass2") define VK_KHR_CREATE_RENDERPASS2_EXTENSION_NAME "VK_KHR_create_renderpass2" - -// 112 -@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 -@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" - -// 113 -@extension("VK_KHR_external_fence_capabilities") define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 -@extension("VK_KHR_external_fence_capabilities") define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" - -// 114 -@extension("VK_KHR_external_fence") define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 -@extension("VK_KHR_external_fence") define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" - -// 115 -@extension("VK_KHR_external_fence_win32") define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 -@extension("VK_KHR_external_fence_win32") define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" - -// 116 -@extension("VK_KHR_external_fence_fd") define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 -@extension("VK_KHR_external_fence_fd") define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" - -// 118 -@extension("VK_KHR_maintenance2") define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 -@extension("VK_KHR_maintenance2") define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" - -// 120 -@extension("VK_KHR_get_surface_capabilities2") define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 -@extension("VK_KHR_get_surface_capabilities2") define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" - -// 121 -@extension("VK_KHR_variable_pointers") define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 -@extension("VK_KHR_variable_pointers") define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" - -// 122 -@extension("VK_KHR_get_display_properties2") define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 -@extension("VK_KHR_get_display_properties2") define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" - -// 123 -@extension("VK_MVK_ios_surface") define VK_MVK_IOS_SURFACE_SPEC_VERSION 1 -@extension("VK_MVK_ios_surface") define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" - -// 124 -@extension("VK_MVK_macos_surface") define VK_MVK_MACOS_SURFACE_SPEC_VERSION 1 -@extension("VK_MVK_macos_surface") define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" - -// 126 -@extension("VK_EXT_external_memory_dma_buf") define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 -@extension("VK_EXT_external_memory_dma_buf") define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" - -// 127 -@extension("VK_EXT_queue_family_foreign") define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 -@extension("VK_EXT_queue_family_foreign") define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" - -// 128 -@extension("VK_KHR_dedicated_allocation") define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 -@extension("VK_KHR_dedicated_allocation") define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" - -// 128 -@extension("VK_EXT_debug_utils") define VK_EXT_DEBUG_UTILS_SPEC_VERSION 1 -@extension("VK_EXT_debug_utils") define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" - -// 130 -@extension("VK_ANDROID_external_memory_android_hardware_buffer") define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3 -@extension("VK_ANDROID_external_memory_android_hardware_buffer") define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" - -// 131 -@extension("VK_EXT_sampler_filter_minmax") define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 -@extension("VK_EXT_sampler_filter_minmax") define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" - -// 132 -@extension("VK_KHR_storage_buffer_storage_class") define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 -@extension("VK_KHR_storage_buffer_storage_class") define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" - -// 133 -@extension("VK_AMD_gpu_shader_int16") define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 -@extension("VK_AMD_gpu_shader_int16") define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" - -// 137 -@extension("VK_AMD_mixed_attachment_samples") define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 -@extension("VK_AMD_mixed_attachment_samples") define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" - -// 138 -@extension("VK_AMD_shader_fragment_mask") define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 -@extension("VK_AMD_shader_fragment_mask") define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" - -// 139 -@extension("VK_EXT_inline_uniform_block") define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1 -@extension("VK_EXT_inline_uniform_block") define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block" - -// 141 -@extension("VK_EXT_shader_stencil_export") define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 -@extension("VK_EXT_shader_stencil_export") define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" - -// 144 -@extension("VK_EXT_sample_locations") define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 -@extension("VK_EXT_sample_locations") define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" - -// 145 -@extension("VK_KHR_relaxed_block_layout") define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 -@extension("VK_KHR_relaxed_block_layout") define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" - -// 147 -@extension("VK_KHR_get_memory_requirements2") define VK_KHR_GET_MEMORY_REQUIREMENTS2_SPEC_VERSION 1 -@extension("VK_KHR_get_memory_requirements2") define VK_KHR_GET_MEMORY_REQUIREMENTS2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" - -// 148 -@extension("VK_KHR_image_format_list") define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 -@extension("VK_KHR_image_format_list") define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" - -// 149 -@extension("VK_EXT_blend_operation_advanced") define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 -@extension("VK_EXT_blend_operation_advanced") define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" - -// 150 -@extension("VK_NV_fragment_coverage_to_color") define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 -@extension("VK_NV_fragment_coverage_to_color") define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" - -// 153 -@extension("VK_NV_framebuffer_mixed_samples") define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 -@extension("VK_NV_framebuffer_mixed_samples") define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" - -// 154 -@extension("VK_NV_fill_rectangle") define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 -@extension("VK_NV_fill_rectangle") define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" - -// 156 -@extension("VK_EXT_post_depth_coverage") define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 -@extension("VK_EXT_post_depth_coverage") define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" - -// 157 -@extension("VK_KHR_sampler_ycbcr_conversion") define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1 -@extension("VK_KHR_sampler_ycbcr_conversion") define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" - -// 158 -@extension("VK_KHR_bind_memory2") define VK_KHR_BIND_MEMORY2_SPEC_VERSION 1 -@extension("VK_KHR_bind_memory2") define VK_KHR_BIND_MEMORY2_EXTENSION_NAME "VK_KHR_bind_memory2" - -// 159 -@extension("VK_EXT_image_drm_format_modifier") define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1 -@extension("VK_EXT_image_drm_format_modifier") define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" - -// 161 -@extension("VK_EXT_validation_cache") define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 -@extension("VK_EXT_validation_cache") define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" - -// 162 -@extension("VK_EXT_descriptor_indexing") define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 -@extension("VK_EXT_descriptor_indexing") define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" - -// 163 -@extension("VK_EXT_shader_viewport_index_layer") define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 -@extension("VK_EXT_shader_viewport_index_layer") define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" - -// 165 -@extension("VK_NV_shading_rate_image") define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3 -@extension("VK_NV_shading_rate_image") define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image" - -// 166 -@extension("VK_NV_ray_tracing") define VK_NV_RAY_TRACING_SPEC_VERSION 3 -@extension("VK_NV_ray_tracing") define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing" - -// 167 -@extension("VK_NV_representative_fragment_test") define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1 -@extension("VK_NV_representative_fragment_test") define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" - -// 169 -@extension("VK_KHR_maintenance3") define VK_KHR_MAINTENANCE3_SPEC_VERSION 1 -@extension("VK_KHR_maintenance3") define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3" - -// 170 -@extension("VK_KHR_draw_indirect_count") define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 -@extension("VK_KHR_draw_indirect_count") define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" - -// 175 -@extension("VK_EXT_global_priority") define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 1 -@extension("VK_EXT_global_priority") define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" - -// 178 -@extension("VK_KHR_8bit_storage") define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 -@extension("VK_KHR_8bit_storage") define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" - -// 179 -@extension("VK_EXT_external_memory_host") define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 -@extension("VK_EXT_external_memory_host") define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" - -// 180 -@extension("VK_AMD_buffer_marker") define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 -@extension("VK_AMD_buffer_marker") define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" - -// 181 -@extension("VK_KHR_shader_atomic_int64") define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1 -@extension("VK_KHR_shader_atomic_int64") define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64" - -// 186 -@extension("VK_AMD_shader_core_properties") define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 -@extension("VK_AMD_shader_core_properties") define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" - -// 190 -@extension("VK_AMD_memory_overallocation_behavior") define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1 -@extension("VK_AMD_memory_overallocation_behavior") define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior" - -// 191 -@extension("VK_EXT_vertex_attribute_divisor") define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 2 -@extension("VK_EXT_vertex_attribute_divisor") define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" - -// 197 -@extension("VK_KHR_driver_properties") define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1 -@extension("VK_KHR_driver_properties") define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties" - -// 198 -@extension("VK_KHR_shader_float_controls") define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 1 -@extension("VK_KHR_shader_float_controls") define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls" - -// 199 -@extension("VK_NV_shader_subgroup_partitioned") define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 -@extension("VK_NV_shader_subgroup_partitioned") define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" - -// 201 -@extension("VK_KHR_swapchain_mutable_format") define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 -@extension("VK_KHR_swapchain_mutable_format") define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" - -// 202 -@extension("VK_NV_compute_shader_derivatives") define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 -@extension("VK_NV_compute_shader_derivatives") define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives" - -// 203 -@extension("VK_NV_mesh_shader") define VK_NV_MESH_SHADER_SPEC_VERSION 1 -@extension("VK_NV_mesh_shader") define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader" - -// 204 -@extension("VK_NV_fragment_shader_barycentric") define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 -@extension("VK_NV_fragment_shader_barycentric") define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" - -// 205 -@extension("VK_NV_shader_image_footprint") define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1 -@extension("VK_NV_shader_image_footprint") define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" - -// 206 -@extension("VK_NV_scissor_exclusive") define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1 -@extension("VK_NV_scissor_exclusive") define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" - -// 207 -@extension("VK_NV_device_diagnostic_checkpoints") define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2 -@extension("VK_NV_device_diagnostic_checkpoints") define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints" - -// 212 -@extension("VK_KHR_vulkan_memory_model") define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 2 -@extension("VK_KHR_vulkan_memory_model") define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" - -// 213 -@extension("VK_EXT_pci_bus_info") define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 -@extension("VK_EXT_pci_bus_info") define VK_EXT_PCI_BUS_INFO_EXENSION_NAME "VK_EXT_pci_bus_info" - -// 215 -@extension("VK_FUCHSIA_imagepipe_surface") define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 -@extension("VK_FUCHSIA_imagepipe_surface") define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface" - -// 219 -@extension("VK_EXT_fragment_density_map") define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 1 -@extension("VK_EXT_fragment_density_map") define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map" - -// 222 -@extension("VK_EXT_scalar_block_layout") define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1 -@extension("VK_EXT_scalar_block_layout") define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout" - -// 224 -@extension("VK_GOOGLE_hlsl_functionality1") define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 1 -@extension("VK_GOOGLE_hlsl_functionality1") define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" - -// 225 -@extension("VK_GOOGLE_decorate_string") define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1 -@extension("VK_GOOGLE_decorate_string") define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string" - -// 247 -@extension("VK_EXT_separate_stencil_usage") define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1 -@extension("VK_EXT_separate_stencil_usage") define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage" - -///////////// -// Types // -///////////// - -type u32 VkBool32 -type u32 VkFlags -type u64 VkDeviceSize -type u32 VkSampleMask - -/// Dispatchable handle types. -@dispatchHandle type u64 VkInstance -@dispatchHandle type u64 VkPhysicalDevice -@dispatchHandle type u64 VkDevice -@dispatchHandle type u64 VkQueue -@dispatchHandle type u64 VkCommandBuffer - -/// Non dispatchable handle types. -@nonDispatchHandle type u64 VkDeviceMemory -@nonDispatchHandle type u64 VkCommandPool -@nonDispatchHandle type u64 VkBuffer -@nonDispatchHandle type u64 VkBufferView -@nonDispatchHandle type u64 VkImage -@nonDispatchHandle type u64 VkImageView -@nonDispatchHandle type u64 VkShaderModule -@nonDispatchHandle type u64 VkPipeline -@nonDispatchHandle type u64 VkPipelineLayout -@nonDispatchHandle type u64 VkSampler -@nonDispatchHandle type u64 VkDescriptorSet -@nonDispatchHandle type u64 VkDescriptorSetLayout -@nonDispatchHandle type u64 VkDescriptorPool -@nonDispatchHandle type u64 VkFence -@nonDispatchHandle type u64 VkSemaphore -@nonDispatchHandle type u64 VkEvent -@nonDispatchHandle type u64 VkQueryPool -@nonDispatchHandle type u64 VkFramebuffer -@nonDispatchHandle type u64 VkRenderPass -@nonDispatchHandle type u64 VkPipelineCache - -@vulkan1_1 -@nonDispatchHandle type u64 VkSamplerYcbcrConversion -@nonDispatchHandle type u64 VkDescriptorUpdateTemplate - -// 1 -@extension("VK_KHR_surface") @nonDispatchHandle type u64 VkSurfaceKHR - -// 2 -@extension("VK_KHR_swapchain") @nonDispatchHandle type u64 VkSwapchainKHR - -// 3 -@extension("VK_KHR_display") @nonDispatchHandle type u64 VkDisplayKHR -@extension("VK_KHR_display") @nonDispatchHandle type u64 VkDisplayModeKHR - -// 12 -@extension("VK_EXT_debug_report") @nonDispatchHandle type u64 VkDebugReportCallbackEXT - -// 86 -@extension("VK_KHR_descriptor_update_template") @nonDispatchHandle type u64 VkDescriptorUpdateTemplateKHR - -// 87 -@extension("VK_NVX_device_generated_commands") @nonDispatchHandle type u64 VkObjectTableNVX -@extension("VK_NVX_device_generated_commands") @nonDispatchHandle type u64 VkIndirectCommandsLayoutNVX - -// 129 -@extension("VK_EXT_debug_utils") @nonDispatchHandle type u64 VkDebugUtilsMessengerEXT - -// 157 -@extension("VK_KHR_sampler_ycbcr_conversion") @nonDispatchHandle type u64 VkSamplerYcbcrConversionKHR - -// 161 -@extension("VK_EXT_validation_cache") @nonDispatchHandle type u64 VkValidationCacheEXT - -// 166 -@extension("VK_NV_ray_tracing") @nonDispatchHandle type u64 VkAccelerationStructureNV - -///////////// -// Enums // -///////////// - -enum VkImageLayout { - VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000, /// Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation) - VK_IMAGE_LAYOUT_GENERAL = 0x00000001, /// General layout when image can be used for any kind of access - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002, /// Optimal layout when image is only used for color attachment read/write - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, /// Optimal layout when image is only used for depth/stencil attachment read/write - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, /// Optimal layout when image is used for read only depth/stencil attachment and shader access - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, /// Optimal layout when image is used for read only shader access - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 0x00000006, /// Optimal layout when image is used only as source of transfer operations - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations - VK_IMAGE_LAYOUT_PREINITIALIZED = 0x00000008, /// Initial layout used when the data is populated by the CPU - - //@vulkan1_1 - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, - - //@extension("VK_KHR_swapchain") // 2 - VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, - - //@extension("VK_KHR_shared_presentable_image") // 112 - VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, - - //@extension("VK_KHR_maintenance2") // 118 - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000117000, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000117001, - - //@extension("VK_NV_shading_rate_image") // 165 - VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003, - - //@extension("VK_EXT_fragment_density_map") // 219 - VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, -} - -enum VkAttachmentLoadOp { - VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000, - VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001, - VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002, -} - -enum VkAttachmentStoreOp { - VK_ATTACHMENT_STORE_OP_STORE = 0x00000000, - VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000001, -} - -enum VkImageType { - VK_IMAGE_TYPE_1D = 0x00000000, - VK_IMAGE_TYPE_2D = 0x00000001, - VK_IMAGE_TYPE_3D = 0x00000002, -} - -enum VkImageTiling { - VK_IMAGE_TILING_OPTIMAL = 0x00000000, - VK_IMAGE_TILING_LINEAR = 0x00000001, - - //@extension("VK_EXT_image_drm_format_modifier") // 159 - VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, -} - -enum VkImageViewType { - VK_IMAGE_VIEW_TYPE_1D = 0x00000000, - VK_IMAGE_VIEW_TYPE_2D = 0x00000001, - VK_IMAGE_VIEW_TYPE_3D = 0x00000002, - VK_IMAGE_VIEW_TYPE_CUBE = 0x00000003, - VK_IMAGE_VIEW_TYPE_1D_ARRAY = 0x00000004, - VK_IMAGE_VIEW_TYPE_2D_ARRAY = 0x00000005, - VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 0x00000006, -} - -enum VkCommandBufferLevel { - VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0x00000000, - VK_COMMAND_BUFFER_LEVEL_SECONDARY = 0x00000001, -} - -enum VkComponentSwizzle { - VK_COMPONENT_SWIZZLE_IDENTITY = 0x00000000, - VK_COMPONENT_SWIZZLE_ZERO = 0x00000001, - VK_COMPONENT_SWIZZLE_ONE = 0x00000002, - VK_COMPONENT_SWIZZLE_R = 0x00000003, - VK_COMPONENT_SWIZZLE_G = 0x00000004, - VK_COMPONENT_SWIZZLE_B = 0x00000005, - VK_COMPONENT_SWIZZLE_A = 0x00000006, -} - -enum VkDescriptorType { - VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000, - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 0x00000001, - VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 0x00000002, - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 0x00000003, - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 0x00000004, - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 0x00000005, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 0x00000007, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 0x00000009, - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 0x0000000a, - - //@extension("VK_EXT_inline_uniform_block") // 139 - VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000, - - //@extension("VK_NV_ray_tracing") // 166 - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, -} - -enum VkQueryType { - VK_QUERY_TYPE_OCCLUSION = 0x00000000, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, /// Optional - VK_QUERY_TYPE_TIMESTAMP = 0x00000002, - - //@extension("VK_EXT_transform_feedback") // 29 - VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, - - //@extension("VK_NV_ray_tracing") // 166 - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, -} - -enum VkBorderColor { - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0x00000000, - VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 0x00000001, - VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 0x00000002, - VK_BORDER_COLOR_INT_OPAQUE_BLACK = 0x00000003, - VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 0x00000004, - VK_BORDER_COLOR_INT_OPAQUE_WHITE = 0x00000005, -} - -enum VkPipelineBindPoint { - VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000000, - VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000001, - - //@extension("VK_NV_ray_tracing") // 166 - VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = 1000165000, -} - -enum VkPrimitiveTopology { - VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0x00000000, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 0x00000001, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 0x00000002, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 0x00000006, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 0x00000007, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 0x00000008, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 0x00000009, - VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 0x0000000a, -} - -enum VkSharingMode { - VK_SHARING_MODE_EXCLUSIVE = 0x00000000, - VK_SHARING_MODE_CONCURRENT = 0x00000001, -} - -enum VkIndexType { - VK_INDEX_TYPE_UINT16 = 0x00000000, - VK_INDEX_TYPE_UINT32 = 0x00000001, - - //@extension("VK_NV_ray_tracing") // 166 - VK_INDEX_TYPE_NONE_NV = 1000165000, -} - -enum VkFilter { - VK_FILTER_NEAREST = 0x00000000, - VK_FILTER_LINEAR = 0x00000001, - - //@extension("VK_IMG_filter_cubic") // 16 - VK_FILTER_CUBIC_IMG = 1000015000, -} - -enum VkSamplerMipmapMode { - VK_SAMPLER_MIPMAP_MODE_NEAREST = 0x00000001, /// Choose nearest mip level - VK_SAMPLER_MIPMAP_MODE_LINEAR = 0x00000002, /// Linear filter between mip levels -} - -enum VkSamplerAddressMode { - VK_SAMPLER_ADDRESS_MODE_REPEAT = 0x00000000, - VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 0x00000001, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 0x00000002, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 0x00000003, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 0x00000004, -} - -enum VkCompareOp { - VK_COMPARE_OP_NEVER = 0x00000000, - VK_COMPARE_OP_LESS = 0x00000001, - VK_COMPARE_OP_EQUAL = 0x00000002, - VK_COMPARE_OP_LESS_OR_EQUAL = 0x00000003, - VK_COMPARE_OP_GREATER = 0x00000004, - VK_COMPARE_OP_NOT_EQUAL = 0x00000005, - VK_COMPARE_OP_GREATER_OR_EQUAL = 0x00000006, - VK_COMPARE_OP_ALWAYS = 0x00000007, -} - -enum VkPolygonMode { - VK_POLYGON_MODE_FILL = 0x00000000, - VK_POLYGON_MODE_LINE = 0x00000001, - VK_POLYGON_MODE_POINT = 0x00000002, - - //@extension("VK_NV_fill_rectangle") // 154 - VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, -} - -enum VkFrontFace { - VK_FRONT_FACE_COUNTER_CLOCKWISE = 0x00000000, - VK_FRONT_FACE_CLOCKWISE = 0x00000001, -} - -enum VkBlendFactor { - VK_BLEND_FACTOR_ZERO = 0x00000000, - VK_BLEND_FACTOR_ONE = 0x00000001, - VK_BLEND_FACTOR_SRC_COLOR = 0x00000002, - VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 0x00000003, - VK_BLEND_FACTOR_DST_COLOR = 0x00000004, - VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 0x00000005, - VK_BLEND_FACTOR_SRC_ALPHA = 0x00000006, - VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 0x00000007, - VK_BLEND_FACTOR_DST_ALPHA = 0x00000008, - VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 0x00000009, - VK_BLEND_FACTOR_CONSTANT_COLOR = 0x0000000a, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 0x0000000b, - VK_BLEND_FACTOR_CONSTANT_ALPHA = 0x0000000c, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d, - VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 0x0000000e, - VK_BLEND_FACTOR_SRC1_COLOR = 0x0000000f, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 0x00000010, - VK_BLEND_FACTOR_SRC1_ALPHA = 0x00000011, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 0x00000012, -} - -enum VkBlendOp { - VK_BLEND_OP_ADD = 0x00000000, - VK_BLEND_OP_SUBTRACT = 0x00000001, - VK_BLEND_OP_REVERSE_SUBTRACT = 0x00000002, - VK_BLEND_OP_MIN = 0x00000003, - VK_BLEND_OP_MAX = 0x00000004, - - //@extension("VK_EXT_blend_operation_advanced") // 149 - VK_BLEND_OP_ZERO_EXT = 1000148000, - VK_BLEND_OP_SRC_EXT = 1000148001, - VK_BLEND_OP_DST_EXT = 1000148002, - VK_BLEND_OP_SRC_OVER_EXT = 1000148003, - VK_BLEND_OP_DST_OVER_EXT = 1000148004, - VK_BLEND_OP_SRC_IN_EXT = 1000148005, - VK_BLEND_OP_DST_IN_EXT = 1000148006, - VK_BLEND_OP_SRC_OUT_EXT = 1000148007, - VK_BLEND_OP_DST_OUT_EXT = 1000148008, - VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, - VK_BLEND_OP_DST_ATOP_EXT = 1000148010, - VK_BLEND_OP_XOR_EXT = 1000148011, - VK_BLEND_OP_MULTIPLY_EXT = 1000148012, - VK_BLEND_OP_SCREEN_EXT = 1000148013, - VK_BLEND_OP_OVERLAY_EXT = 1000148014, - VK_BLEND_OP_DARKEN_EXT = 1000148015, - VK_BLEND_OP_LIGHTEN_EXT = 1000148016, - VK_BLEND_OP_COLORDODGE_EXT = 1000148017, - VK_BLEND_OP_COLORBURN_EXT = 1000148018, - VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, - VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, - VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, - VK_BLEND_OP_EXCLUSION_EXT = 1000148022, - VK_BLEND_OP_INVERT_EXT = 1000148023, - VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, - VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, - VK_BLEND_OP_LINEARBURN_EXT = 1000148026, - VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, - VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, - VK_BLEND_OP_PINLIGHT_EXT = 1000148029, - VK_BLEND_OP_HARDMIX_EXT = 1000148030, - VK_BLEND_OP_HSL_HUE_EXT = 1000148031, - VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, - VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, - VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, - VK_BLEND_OP_PLUS_EXT = 1000148035, - VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, - VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, - VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, - VK_BLEND_OP_MINUS_EXT = 1000148039, - VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, - VK_BLEND_OP_CONTRAST_EXT = 1000148041, - VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, - VK_BLEND_OP_RED_EXT = 1000148043, - VK_BLEND_OP_GREEN_EXT = 1000148044, - VK_BLEND_OP_BLUE_EXT = 1000148045, -} - -enum VkStencilOp { - VK_STENCIL_OP_KEEP = 0x00000000, - VK_STENCIL_OP_ZERO = 0x00000001, - VK_STENCIL_OP_REPLACE = 0x00000002, - VK_STENCIL_OP_INCREMENT_AND_CLAMP = 0x00000003, - VK_STENCIL_OP_DECREMENT_AND_CLAMP = 0x00000004, - VK_STENCIL_OP_INVERT = 0x00000005, - VK_STENCIL_OP_INCREMENT_AND_WRAP = 0x00000006, - VK_STENCIL_OP_DECREMENT_AND_WRAP = 0x00000007, -} - -enum VkLogicOp { - VK_LOGIC_OP_CLEAR = 0x00000000, - VK_LOGIC_OP_AND = 0x00000001, - VK_LOGIC_OP_AND_REVERSE = 0x00000002, - VK_LOGIC_OP_COPY = 0x00000003, - VK_LOGIC_OP_AND_INVERTED = 0x00000004, - VK_LOGIC_OP_NO_OP = 0x00000005, - VK_LOGIC_OP_XOR = 0x00000006, - VK_LOGIC_OP_OR = 0x00000007, - VK_LOGIC_OP_NOR = 0x00000008, - VK_LOGIC_OP_EQUIVALENT = 0x00000009, - VK_LOGIC_OP_INVERT = 0x0000000a, - VK_LOGIC_OP_OR_REVERSE = 0x0000000b, - VK_LOGIC_OP_COPY_INVERTED = 0x0000000c, - VK_LOGIC_OP_OR_INVERTED = 0x0000000d, - VK_LOGIC_OP_NAND = 0x0000000e, - VK_LOGIC_OP_SET = 0x0000000f, -} - -enum VkSystemAllocationScope { - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0x00000000, - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 0x00000001, - VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 0x00000002, - VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 0x00000003, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 0x00000004, -} - -enum VkInternalAllocationType { - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0x00000000, -} - -enum VkPhysicalDeviceType { - VK_PHYSICAL_DEVICE_TYPE_OTHER = 0x00000000, - VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 0x00000001, - VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 0x00000002, - VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 0x00000003, - VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004, -} - -enum VkVertexInputRate { - VK_VERTEX_INPUT_RATE_VERTEX = 0x00000000, - VK_VERTEX_INPUT_RATE_INSTANCE = 0x00000001, -} - -/// Vulkan format definitions -enum VkFormat { - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM_PACK8 = 1, - VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, - VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, - VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, - VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, - VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, - VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, - VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, - VK_FORMAT_R8_UNORM = 9, - VK_FORMAT_R8_SNORM = 10, - VK_FORMAT_R8_USCALED = 11, - VK_FORMAT_R8_SSCALED = 12, - VK_FORMAT_R8_UINT = 13, - VK_FORMAT_R8_SINT = 14, - VK_FORMAT_R8_SRGB = 15, - VK_FORMAT_R8G8_UNORM = 16, - VK_FORMAT_R8G8_SNORM = 17, - VK_FORMAT_R8G8_USCALED = 18, - VK_FORMAT_R8G8_SSCALED = 19, - VK_FORMAT_R8G8_UINT = 20, - VK_FORMAT_R8G8_SINT = 21, - VK_FORMAT_R8G8_SRGB = 22, - VK_FORMAT_R8G8B8_UNORM = 23, - VK_FORMAT_R8G8B8_SNORM = 24, - VK_FORMAT_R8G8B8_USCALED = 25, - VK_FORMAT_R8G8B8_SSCALED = 26, - VK_FORMAT_R8G8B8_UINT = 27, - VK_FORMAT_R8G8B8_SINT = 28, - VK_FORMAT_R8G8B8_SRGB = 29, - VK_FORMAT_B8G8R8_UNORM = 30, - VK_FORMAT_B8G8R8_SNORM = 31, - VK_FORMAT_B8G8R8_USCALED = 32, - VK_FORMAT_B8G8R8_SSCALED = 33, - VK_FORMAT_B8G8R8_UINT = 34, - VK_FORMAT_B8G8R8_SINT = 35, - VK_FORMAT_B8G8R8_SRGB = 36, - VK_FORMAT_R8G8B8A8_UNORM = 37, - VK_FORMAT_R8G8B8A8_SNORM = 38, - VK_FORMAT_R8G8B8A8_USCALED = 39, - VK_FORMAT_R8G8B8A8_SSCALED = 40, - VK_FORMAT_R8G8B8A8_UINT = 41, - VK_FORMAT_R8G8B8A8_SINT = 42, - VK_FORMAT_R8G8B8A8_SRGB = 43, - VK_FORMAT_B8G8R8A8_UNORM = 44, - VK_FORMAT_B8G8R8A8_SNORM = 45, - VK_FORMAT_B8G8R8A8_USCALED = 46, - VK_FORMAT_B8G8R8A8_SSCALED = 47, - VK_FORMAT_B8G8R8A8_UINT = 48, - VK_FORMAT_B8G8R8A8_SINT = 49, - VK_FORMAT_B8G8R8A8_SRGB = 50, - VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, - VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, - VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, - VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, - VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, - VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, - VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, - VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, - VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, - VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, - VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, - VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, - VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, - VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, - VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, - VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, - VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, - VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, - VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, - VK_FORMAT_R16_UNORM = 70, - VK_FORMAT_R16_SNORM = 71, - VK_FORMAT_R16_USCALED = 72, - VK_FORMAT_R16_SSCALED = 73, - VK_FORMAT_R16_UINT = 74, - VK_FORMAT_R16_SINT = 75, - VK_FORMAT_R16_SFLOAT = 76, - VK_FORMAT_R16G16_UNORM = 77, - VK_FORMAT_R16G16_SNORM = 78, - VK_FORMAT_R16G16_USCALED = 79, - VK_FORMAT_R16G16_SSCALED = 80, - VK_FORMAT_R16G16_UINT = 81, - VK_FORMAT_R16G16_SINT = 82, - VK_FORMAT_R16G16_SFLOAT = 83, - VK_FORMAT_R16G16B16_UNORM = 84, - VK_FORMAT_R16G16B16_SNORM = 85, - VK_FORMAT_R16G16B16_USCALED = 86, - VK_FORMAT_R16G16B16_SSCALED = 87, - VK_FORMAT_R16G16B16_UINT = 88, - VK_FORMAT_R16G16B16_SINT = 89, - VK_FORMAT_R16G16B16_SFLOAT = 90, - VK_FORMAT_R16G16B16A16_UNORM = 91, - VK_FORMAT_R16G16B16A16_SNORM = 92, - VK_FORMAT_R16G16B16A16_USCALED = 93, - VK_FORMAT_R16G16B16A16_SSCALED = 94, - VK_FORMAT_R16G16B16A16_UINT = 95, - VK_FORMAT_R16G16B16A16_SINT = 96, - VK_FORMAT_R16G16B16A16_SFLOAT = 97, - VK_FORMAT_R32_UINT = 98, - VK_FORMAT_R32_SINT = 99, - VK_FORMAT_R32_SFLOAT = 100, - VK_FORMAT_R32G32_UINT = 101, - VK_FORMAT_R32G32_SINT = 102, - VK_FORMAT_R32G32_SFLOAT = 103, - VK_FORMAT_R32G32B32_UINT = 104, - VK_FORMAT_R32G32B32_SINT = 105, - VK_FORMAT_R32G32B32_SFLOAT = 106, - VK_FORMAT_R32G32B32A32_UINT = 107, - VK_FORMAT_R32G32B32A32_SINT = 108, - VK_FORMAT_R32G32B32A32_SFLOAT = 109, - VK_FORMAT_R64_UINT = 110, - VK_FORMAT_R64_SINT = 111, - VK_FORMAT_R64_SFLOAT = 112, - VK_FORMAT_R64G64_UINT = 113, - VK_FORMAT_R64G64_SINT = 114, - VK_FORMAT_R64G64_SFLOAT = 115, - VK_FORMAT_R64G64B64_UINT = 116, - VK_FORMAT_R64G64B64_SINT = 117, - VK_FORMAT_R64G64B64_SFLOAT = 118, - VK_FORMAT_R64G64B64A64_UINT = 119, - VK_FORMAT_R64G64B64A64_SINT = 120, - VK_FORMAT_R64G64B64A64_SFLOAT = 121, - VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, - VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, - VK_FORMAT_D16_UNORM = 124, - VK_FORMAT_X8_D24_UNORM_PACK32 = 125, - VK_FORMAT_D32_SFLOAT = 126, - VK_FORMAT_S8_UINT = 127, - VK_FORMAT_D16_UNORM_S8_UINT = 128, - VK_FORMAT_D24_UNORM_S8_UINT = 129, - VK_FORMAT_D32_SFLOAT_S8_UINT = 130, - VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, - VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, - VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, - VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, - VK_FORMAT_BC2_UNORM_BLOCK = 135, - VK_FORMAT_BC2_SRGB_BLOCK = 136, - VK_FORMAT_BC3_UNORM_BLOCK = 137, - VK_FORMAT_BC3_SRGB_BLOCK = 138, - VK_FORMAT_BC4_UNORM_BLOCK = 139, - VK_FORMAT_BC4_SNORM_BLOCK = 140, - VK_FORMAT_BC5_UNORM_BLOCK = 141, - VK_FORMAT_BC5_SNORM_BLOCK = 142, - VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, - VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, - VK_FORMAT_BC7_UNORM_BLOCK = 145, - VK_FORMAT_BC7_SRGB_BLOCK = 146, - VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, - VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, - VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, - VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, - VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, - VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, - VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, - VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, - VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, - VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, - VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, - VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, - VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, - VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, - VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, - VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, - VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, - VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, - VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, - VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, - VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, - VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, - VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, - VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, - VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, - VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, - VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, - VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, - VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, - VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, - VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, - VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, - VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, - VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, - VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, - VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, - - //@vulkan1_1 - VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, - VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, - VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, - VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, - VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, - VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, - - //@extension("VK_IMG_format_pvrtc") // 28 - VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, - VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, - VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, - VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, - VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, - VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, - VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, - VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, - - //@extension("VK_KHR_sampler_ycbcr_conversion") // 157 - VK_FORMAT_G8B8G8R8_422_UNORM_KHR = 1000156000, - VK_FORMAT_B8G8R8G8_422_UNORM_KHR = 1000156001, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = 1000156002, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = 1000156003, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = 1000156004, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = 1000156005, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = 1000156006, - VK_FORMAT_R10X6_UNORM_PACK16_KHR = 1000156007, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = 1000156008, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = 1000156009, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = 1000156010, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = 1000156011, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = 1000156013, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = 1000156015, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016, - VK_FORMAT_R12X4_UNORM_PACK16_KHR = 1000156017, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = 1000156018, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = 1000156019, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = 1000156020, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = 1000156021, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = 1000156023, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = 1000156025, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026, - VK_FORMAT_G16B16G16R16_422_UNORM_KHR = 1000156027, - VK_FORMAT_B16G16R16G16_422_UNORM_KHR = 1000156028, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = 1000156029, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = 1000156030, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = 1000156031, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = 1000156032, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = 1000156033, -} - -/// Structure type enumerant -enum VkStructureType { - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, - VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, - VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, - VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, - - //@vulkan1_1 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000, - VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, - - //@extension("VK_KHR_swapchain") // 2 - VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, - VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, - // added as interaction from VK_KHR_device_group / VK 1.1 - VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, - VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, - - //@extension("VK_KHR_display") // 3 - VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, - VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, - - //@extension("VK_KHR_display_swapchain") // 4 - VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 1000003000, - - //@extension("VK_KHR_xlib_surface") // 5 - VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, - - //@extension("VK_KHR_xcb_surface") // 6 - VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, - - //@extension("VK_KHR_wayland_surface") // 7 - VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, - - //@extension("VK_KHR_android_surface") // 9 - VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, - - //@extension("VK_KHR_win32_surface") // 10 - VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, - - //@extension("VK_ANDROID_native_buffer") // 11 - VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID = 1000010000, - VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID = 1000010001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID = 1000010002, - - //@extension("VK_EXT_debug_report") // 12 - VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, - - //@extension("VK_AMD_rasterization_order") // 19 - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, - - //@extension("VK_EXT_debug_marker") // 23 - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, - VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, - - //@extension("VK_NV_dedicated_allocation") // 27 - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, - - //@extension("VK_EXT_transform_feedback") // 29 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, - - //@extension("VK_AMD_texture_gather_bias_lod") // 42 - VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, - - //@extension("VK_NV_corner_sampled_image") // 51 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, - - //@extension("VK_KHR_multiview") // 54 - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = 1000053000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = 1000053001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = 1000053002, - - //@extension("VK_NV_external_memory") // 57 - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, - - //@extension("VK_NV_external_memory_win32") // 58 - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, - - //@extension("VK_NV_win32_keyed_mutex") // 59 - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, - - //@extension("VK_KHR_get_physical_device_properties2") // 60 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008, - - //@extension("VK_KHR_device_group") // 61 - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = 1000060000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = 1000060003, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = 1000060004, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = 1000060005, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = 1000060006, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, - // tokens 08-12 are listed with VK_KHR_swapchain - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = 1000060013, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = 1000060014, - - //@extension("VK_EXT_validation_flags") // 62 - VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, - - //@extension("VK_NN_vi_surface") // 63 - VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, - - //@extension("VK_EXT_astc_decode_mode") // 68 - VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, - - //@extension("VK_KHR_device_group_creation") // 71 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = 1000070000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = 1000070001, - - //@extension("VK_KHR_external_memory_capabilities") // 72 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004, - - //@extension("VK_KHR_external_memory") // 73 - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002, - - //@extension("VK_KHR_external_memory_win32") // 74 - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, - VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, - - //@extension("VK_KHR_external_memory_fd") // 75 - VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, - VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, - - //@extension("VK_KHR_win32_keyed_mutex") // 76 - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, - - //@extension("VK_KHR_external_semaphore_capabilities") // 77 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001, - - //@extension("VK_KHR_external_semaphore") // 78 - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000, - - //@extension("VK_KHR_external_semaphore_win32") // 79 - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, - VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, - - //@extension("VK_KHR_external_semaphore_fd") // 80 - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, - - //@extension("VK_KHR_push_descriptor") // 81 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, - - //@extension("VK_KHR_16bit_storage") // 84 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000, - - //@extension("VK_KHR_incremental_present") // 85 - VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, - - //@extension("VK_EXT_conditional_rendering") // 82 - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, - VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, - - //@extension("VK_KHR_shader_float16_int8") // 83 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = 1000082000, - - //@extension("VK_KHR_descriptor_update_template") // 86 - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000, - - //@extension("VK_NVX_device_generated_commands") // 87 - VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, - VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, - VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, - VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, - VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, - - //@extension("VK_NV_clip_space_w_scaling") // 88 - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, - - //@extension("VK_EXT_display_surface_counter") // 91 - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, - - //@extension("VK_EXT_display_control") // 92 - VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, - VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, - VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, - VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, - - //@extension("VK_GOOGLE_display_timing") // 93 - VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, - - //@extension("VK_NVX_multiview_per_view_attributes") // 98 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, - - //@extension("VK_NV_viewport_swizzle") // 99 - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, - - //@extension("VK_EXT_discard_rectangles") // 100 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, - VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, - - //@extension("VK_EXT_conservative_rasterization") // 102 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, - - //@extension("VK_KHR_create_renderpass2") // 110 - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004, - VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005, - VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006, - - //@extension("VK_EXT_hdr_metadata") // 106 - VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, - - //@extension("VK_KHR_shared_presentable_image") // 112 - VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, - - //@extension("VK_KHR_external_fence_capabilities") // 113 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001, - - //@extension("VK_KHR_external_fence") // 114 - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000, - - //@extension("VK_KHR_external_fence_win32") // 115 - VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, - VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, - VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, - - //@extension("VK_KHR_external_fence_fd") // 117 - VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, - VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, - - //@extension("VK_KHR_maintenance2") // 118 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = 1000117000, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = 1000117001, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = 1000117002, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = 1000117003, - - //@extension("VK_KHR_get_surface_capabilities2") // 120 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, - VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, - - //@extension("VK_KHR_variable_pointers") // 121 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000, - - //@extension("VK_KHR_display_properties2") // 122 - VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, - VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, - - //@extension("VK_MVK_ios_surface") // 123 - VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, - - //@extension("VK_MVK_macos_surface") // 124 - VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, - - //@extension("VK_KHR_dedicated_allocation") // 128 - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001, - - //@extension("VK_EXT_debug_utils") // 129 - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, - - //@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, - VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, - VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, - - //@extension("VK_EXT_sampler_filter_minmax") // 131 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, - VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, - - //@extension("VK_EXT_inline_uniform_block") // 139 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003, - - //@extension("VK_EXT_sample_locations") // 144 - VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, - VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, - VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, - VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, - - //@extension("VK_KHR_get_memory_requirements2") // 147 - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004, - - //@extension("VK_KHR_image_format_list") // 148 - VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000, - - //@extension("VK_EXT_blend_operation_advanced") // 149 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, - - //@extension("VK_NV_fragment_coverage_to_color") // 150 - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, - - //@extension("VK_NV_framebuffer_mixed_samples") // 153 - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, - - //@extension("VK_KHR_sampler_ycbcr_conversion") // 157 - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = 1000156000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = 1000156001, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = 1000156002, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = 1000156003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = 1000156005, - - //@extension("VK_EXT_image_drm_format_modifier") // 159 - VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, - VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, - - //@extension("VK_KHR_bind_memory2") // 158 - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = 1000157000, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = 1000157001, - - //@extension("VK_EXT_validation_cache") // 161 - VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, - VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, - - //@extension("VK_EXT_descriptor_indexing") // 162 - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004, - - //@extension("VK_NV_shading_rate_image") // 165 - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, - - //@extension("VK_NV_ray_tracing") // 166 - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, - VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, - VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, - VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, - VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, - VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, - - //@extension("VK_NV_representative_fragment_test") // 167 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, - VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, - - //@extension("VK_KHR_maintenance3") // 169 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = 1000168000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = 1000168001, - - //@extension("VK_EXT_global_priority") // 175 - VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, - - //@extension("VK_KHR_8bit_storage") // 178 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000, - - //@extension("VK_EXT_external_memory_host") // 179 - VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, - VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, - - //@extension("VK_KHR_shader_atomic_int64") // 181 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000, - - //@extension("VK_EXT_calibrated_timestamps") // 185 - VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, - - //@extension("VK_KHR_driver_properties") // 197 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000, - - //@extension("VK_KHR_shader_float_controls") // 198 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = 1000197000, - - //@extension("VK_AMD_shader_core_properties") // 186 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, - - //@extension("VK_AMD_memory_overallocation_behavior") // 190 - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, - - //@extension("VK_EXT_vertex_attribute_divisor") // 191 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, - - //@extension("VK_NV_device_diagnostic_checkpoints") // 207 - VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, - - //@extension("VK_KHR_vulkan_memory_model") // 212 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000, - - //@extension("VK_EXT_pci_bus_info") // 213 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, - - //@extension("VK_FUCHSIA_imagepipe_surface") // 215 - VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, - - //@extension("VK_EXT_fragment_density_map") // 219 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, - VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, - - //@extension("VK_EXT_scalar_block_layout") - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000, - - //@extension("VK_EXT_separate_stencil_usage") // 247 - VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000, -} - -enum VkSubpassContents { - VK_SUBPASS_CONTENTS_INLINE = 0x00000000, - VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001, -} - -enum VkPipelineCacheHeaderVersion { - VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, -} - -@lastUnused(-11) -/// Error and return codes -enum VkResult { - // Return codes for successful operation execution (positive values) - VK_SUCCESS = 0, - VK_NOT_READY = 1, - VK_TIMEOUT = 2, - VK_EVENT_SET = 3, - VK_EVENT_RESET = 4, - VK_INCOMPLETE = 5, - - //@extension("VK_KHR_swapchain") // 2 - VK_SUBOPTIMAL_KHR = 1000001003, - - // Error codes (negative values) - VK_ERROR_OUT_OF_HOST_MEMORY = 0xFFFFFFFF, // -1 - VK_ERROR_OUT_OF_DEVICE_MEMORY = 0xFFFFFFFE, // -2 - VK_ERROR_INITIALIZATION_FAILED = 0xFFFFFFFD, // -3 - VK_ERROR_DEVICE_LOST = 0xFFFFFFFC, // -4 - VK_ERROR_MEMORY_MAP_FAILED = 0xFFFFFFFB, // -5 - VK_ERROR_LAYER_NOT_PRESENT = 0xFFFFFFFA, // -6 - VK_ERROR_EXTENSION_NOT_PRESENT = 0xFFFFFFF9, // -7 - VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8, // -8 - VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7, // -9 - VK_ERROR_TOO_MANY_OBJECTS = 0xFFFFFFF6, // -10 - VK_ERROR_FORMAT_NOT_SUPPORTED = 0xFFFFFFF5, // -11 - VK_ERROR_FRAGMENTED_POOL = 0xFFFFFFF4, // -12 - - //@vulkan1_1 - VK_ERROR_OUT_OF_POOL_MEMORY = 0xC4642878, // -1000069000 - VK_ERROR_INVALID_EXTERNAL_HANDLE = 0xC4641CBD, // -1000072003 - - //@extension("VK_KHR_surface") // 1 - VK_ERROR_SURFACE_LOST_KHR = 0xC4653600, // -1000000000 - VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC46535FF, // -1000000001 - - //@extension("VK_KHR_swapchain") // 2 - VK_ERROR_OUT_OF_DATE_KHR = 0xC4653214, // -1000001004 - - //@extension("VK_KHR_display_swapchain") // 4 - VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC4652A47, // -1000003001 - - //@extension("VK_EXT_debug_report") // 12 - VK_ERROR_VALIDATION_FAILED_EXT = 0xC4650B07, // -1000011001 - - //@extension("VK_NV_glsl_shader") // 13 - VK_ERROR_INVALID_SHADER_NV = 0xC4650720, // -1000012000 - - //@extension("VK_KHR_maintenance1") // 70 - VK_ERROR_OUT_OF_POOL_MEMORY_KHR = 0xC4642878, // -1000069000 - - //@extension("VK_KHR_external_memory") // 73 - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = 0xC4641CBD, // -1000072003 - - //@extension("VK_EXT_image_drm_format_modifier") // 159 - VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = 0xC462CCD0, // -1000158000 - - //@extension("VK_EXT_descriptor_indexing") // 162 - VK_ERROR_FRAGMENTATION_EXT = 0xc462c118, // -1000161000 - - //@extension("VK_EXT_global_priority") // 175 - VK_ERROR_NOT_PERMITTED_EXT = 0xC4628E4F, // -1000174001 -} - -enum VkDynamicState { - VK_DYNAMIC_STATE_VIEWPORT = 0x00000000, - VK_DYNAMIC_STATE_SCISSOR = 0x00000001, - VK_DYNAMIC_STATE_LINE_WIDTH = 0x00000002, - VK_DYNAMIC_STATE_DEPTH_BIAS = 0x00000003, - VK_DYNAMIC_STATE_BLEND_CONSTANTS = 0x00000004, - VK_DYNAMIC_STATE_DEPTH_BOUNDS = 0x00000005, - VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 0x00000006, - VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 0x00000007, - VK_DYNAMIC_STATE_STENCIL_REFERENCE = 0x00000008, - - //@extension("VK_NV_clip_space_w_scaling") // 88 - VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, - - //@extension("VK_EXT_discard_rectangles") // 100 - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, - - //@extension("VK_EXT_sample_locations") // 144 - VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, - - //@extension("VK_NV_shading_rate_image") // 165 - VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, - VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, - - //@extension("VK_NV_scissor_exclusive") // 206 - VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, -} - -enum VkObjectType { - VK_OBJECT_TYPE_UNKNOWN = 0, - VK_OBJECT_TYPE_INSTANCE = 1, - VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, - VK_OBJECT_TYPE_DEVICE = 3, - VK_OBJECT_TYPE_QUEUE = 4, - VK_OBJECT_TYPE_SEMAPHORE = 5, - VK_OBJECT_TYPE_COMMAND_BUFFER = 6, - VK_OBJECT_TYPE_FENCE = 7, - VK_OBJECT_TYPE_DEVICE_MEMORY = 8, - VK_OBJECT_TYPE_BUFFER = 9, - VK_OBJECT_TYPE_IMAGE = 10, - VK_OBJECT_TYPE_EVENT = 11, - VK_OBJECT_TYPE_QUERY_POOL = 12, - VK_OBJECT_TYPE_BUFFER_VIEW = 13, - VK_OBJECT_TYPE_IMAGE_VIEW = 14, - VK_OBJECT_TYPE_SHADER_MODULE = 15, - VK_OBJECT_TYPE_PIPELINE_CACHE = 16, - VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, - VK_OBJECT_TYPE_RENDER_PASS = 18, - VK_OBJECT_TYPE_PIPELINE = 19, - VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, - VK_OBJECT_TYPE_SAMPLER = 21, - VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, - VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, - VK_OBJECT_TYPE_FRAMEBUFFER = 24, - VK_OBJECT_TYPE_COMMAND_POOL = 25, - - //@vulkan1_1 - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, - - //@extension("VK_KHR_surface") // 1 - VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, - - //@extension("VK_KHR_swapchain") // 2 - VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, - - //@extension("VK_KHR_display") // 3 - VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, - VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, - - //@extension("VK_KHR_debug_report") // 12 - VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, - - //@extension("VK_KHR_descriptor_update_template") // 86 - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000, - - //@extension("VK_NVX_device_generated_commands") // 87 - VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000, - VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, - - //@extension("VK_EXT_debug_utils") // 129 - VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, - - //@extension("VK_KHR_sampler_ycbcr_conversion") // 157 - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = 1000156000, - - //@extension("VK_EXT_validation_cache") // 161 - VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, - - //@extension("VK_NV_ray_tracing") // 166 - VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, -} - - -//@vulkan1_1 enums - -enum VkPointClippingBehavior { - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, -} - -enum VkTessellationDomainOrigin { - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, -} - -enum VkSamplerYcbcrModelConversion { - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, -} - -enum VkSamplerYcbcrRange { - VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, -} - -enum VkChromaLocation { - VK_CHROMA_LOCATION_COSITED_EVEN = 0, - VK_CHROMA_LOCATION_MIDPOINT = 1, -} - -enum VkDescriptorUpdateTemplateType { - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, -} - -enum VkVendorId { - VK_VENDOR_ID_VIV = 0x10001, - VK_VENDOR_ID_VSI = 0x10002, - VK_VENDOR_ID_KAZAN = 0x10003, -} - -@extension("VK_KHR_surface") // 1 -enum VkPresentModeKHR { - VK_PRESENT_MODE_IMMEDIATE_KHR = 0x00000000, - VK_PRESENT_MODE_MAILBOX_KHR = 0x00000001, - VK_PRESENT_MODE_FIFO_KHR = 0x00000002, - VK_PRESENT_MODE_FIFO_RELAXED_KHR = 0x00000003, - - //@extension("VK_KHR_shared_presentable_image") // 112 - VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, - VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, -} - -@extension("VK_KHR_surface") // 1 -enum VkColorSpaceKHR { - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0x00000000, - - //@extension("VK_EXT_swapchain_colorspace") // 105 - VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, - VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, - VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003, - VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, - VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, - VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, - VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, - VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, - VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, - VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, - VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, - VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, - VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, - VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, -} - -@extension("VK_EXT_debug_report") // 12 -enum VkDebugReportObjectTypeEXT { - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, - VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, - VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, - VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, - VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, - VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, - VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, - VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, - VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, - VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, - VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, - VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, - VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, - - //extension("VK_EXT_validation_cache") // 161 - VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, - - //extension("VK_KHR_descriptor_update_template") // 86 - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000, - - //@extension("VK_KHR_sampler_ycbcr_conversion") // 157 - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000, - - //@extension("VK_NV_ray_tracing") // 166 - VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, -} - -@extension("VK_AMD_rasterization_order") // 19 -enum VkRasterizationOrderAMD { - VK_RASTERIZATION_ORDER_STRICT_AMD = 0, - VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, -} - -@extension("VK_AMD_shader_info") // 43 -enum VkShaderInfoTypeAMD { - VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, - VK_SHADER_INFO_TYPE_BINARY_AMD = 1, - VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, -} - -@extension("VK_EXT_validation_flags") // 62 -enum VkValidationCheckEXT { - VK_VALIDATION_CHECK_ALL_EXT = 0, - VK_VALIDATION_CHECK_SHADERS_EXT = 1, -} - -@extension("VK_KHR_descriptor_update_template") // 86 -enum VkDescriptorUpdateTemplateTypeKHR { - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, -} - -@extension("VK_NVX_device_generated_commands") // 87 -enum VkIndirectCommandsTokenTypeNVX { - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, -} - -@extension("VK_NVX_device_generated_commands") // 87 -enum VkObjectEntryTypeNVX { - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, - VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, - VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, - VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, - VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, -} - -@extension("VK_EXT_display_control") // 92 -enum VkDisplayPowerStateEXT { - VK_DISPLAY_POWER_STATE_OFF_EXT = 0, - VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, - VK_DISPLAY_POWER_STATE_ON_EXT = 2, -} - -@extension("VK_EXT_display_control") // 92 -enum VkDeviceEventTypeEXT { - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, -} - -@extension("VK_EXT_display_control") // 92 -enum VkDisplayEventTypeEXT { - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, -} - -@extension("VK_NV_viewport_swizzle") // 99 -enum VkViewportCoordinateSwizzleNV { - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, -} - -@extension("VK_EXT_discard_rectangles") // 100 -enum VkDiscardRectangleModeEXT { - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, - VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, -} - -@extension("VK_EXT_conservative_rasterization") // 102 -enum VkConservativeRasterizationModeEXT { - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, - VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, - VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, -} - -@extension("VK_KHR_maintenance2") // 118 -enum VkPointClippingBehaviorKHR { - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = 0, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = 1, -} - -@extension("VK_KHR_maintenance2") // 118 -enum VkTessellationDomainOriginKHR { - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = 0, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = 1, -} - -@extension("VK_EXT_sampler_filter_minmax") // 131 -enum VkSamplerReductionModeEXT { - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, - VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, - VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, -} - -@extension("VK_EXT_blend_operation_advanced") // 149 -enum VkBlendOverlapEXT { - VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, - VK_BLEND_OVERLAP_DISJOINT_EXT = 1, - VK_BLEND_OVERLAP_CONJOINT_EXT = 2, -} - -@extension("VK_NV_framebuffer_mixed_samples") // 153 -enum VkCoverageModulationModeNV { - VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, - VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, - VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, - VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -enum VkSamplerYcbcrModelConversionKHR { - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = 0, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = 1, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = 2, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = 3, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = 4, -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -enum VkSamplerYcbcrRangeKHR { - VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = 0, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = 1, -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -enum VkChromaLocationKHR { - VK_CHROMA_LOCATION_COSITED_EVEN_KHR = 0, - VK_CHROMA_LOCATION_MIDPOINT_KHR = 1, -} - -@extension("VK_EXT_validation_cache") // 161 -enum VkValidationCacheHeaderVersionEXT { - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, -} - -@extension("VK_NV_shading_rate_image") // 165 -enum VkShadingRatePaletteEntryNV { - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, - VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, - VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, - VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, - VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, -} - -@extension("VK_NV_shading_rate_image") // 165 -enum VkCoarseSampleOrderTypeNV { - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, - VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, - VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, - VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, -} - -@extension("VK_NV_ray_tracing") // 166 -enum VkRayTracingShaderGroupTypeNV { - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0, - VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1, - VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = 2, -} - -@extension("VK_NV_ray_tracing") // 166 -enum VkGeometryTypeNV { - VK_GEOMETRY_TYPE_TRIANGLES_NV = 0, - VK_GEOMETRY_TYPE_AABBS_NV = 1, -} - -@extension("VK_NV_ray_tracing") // 166 -enum VkAccelerationStructureTypeNV { - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1, -} - -@extension("VK_NV_ray_tracing") // 166 -enum VkCopyAccelerationStructureModeNV { - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0, - VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1, -} - -@extension("VK_NV_ray_tracing") // 166 -enum VkAccelerationStructureMemoryRequirementsTypeNV { - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, -} - -@extension("VK_EXT_global_priority") // 175 -enum VkQueueGlobalPriorityEXT { - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, -} - -@extension("VK_EXT_calibrated_timestamps") // 185 -enum VkTimeDomainEXT { - VK_TIME_DOMAIN_DEVICE_EXT = 0, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, - VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, -} - -@extension("VK_AMD_memory_overallocation_behavior") // 190 -enum VkMemoryOverallocationBehaviorAMD { - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, -} - -@extension("VK_KHR_driver_properties") // 197 -enum VkDriverIdKHR { - VK_DRIVER_ID_AMD_PROPRIETARY_KHR = 1, - VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = 2, - VK_DRIVER_ID_MESA_RADV_KHR = 3, - VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = 4, - VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = 5, - VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = 6, - VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = 7, - VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = 8, - VK_DRIVER_ID_ARM_PROPRIETARY_KHR = 9, - VK_DRIVER_ID_GOOGLE_PASTEL_KHR = 10, -} - -///////////////// -// Bitfields // -///////////////// - -/// Queue capabilities -type VkFlags VkQueueFlags -bitfield VkQueueFlagBits { - VK_QUEUE_GRAPHICS_BIT = 0x00000001, /// Queue supports graphics operations - VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations - VK_QUEUE_TRANSFER_BIT = 0x00000004, /// Queue supports transfer operations - VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, /// Queue supports sparse resource memory management operations - - //@vulkan1_1 - VK_QUEUE_PROTECTED_BIT = 0x00000010, -} - -/// Memory properties passed into vkAllocMemory(). -type VkFlags VkMemoryPropertyFlags -bitfield VkMemoryPropertyFlagBits { - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, - VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, - VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, - - //@vulkan1_1 - VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, -} - -/// Memory heap flags -type VkFlags VkMemoryHeapFlags -bitfield VkMemoryHeapFlagBits { - VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, - - //@vulkan1_1 - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, - - //@extension("VK_KHR_device_group_creation") // 71 - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = 0x00000002, -} - -/// Access flags -type VkFlags VkAccessFlags -bitfield VkAccessFlagBits { - VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, - VK_ACCESS_INDEX_READ_BIT = 0x00000002, - VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, - VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, - VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, - VK_ACCESS_SHADER_READ_BIT = 0x00000020, - VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, - VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, - VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, - VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, - VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, - VK_ACCESS_HOST_READ_BIT = 0x00002000, - VK_ACCESS_HOST_WRITE_BIT = 0x00004000, - VK_ACCESS_MEMORY_READ_BIT = 0x00008000, - VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, - - //@extension("VK_NVX_device_generated_commands") // 87 - VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, - VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, - - //@extension("VK_EXT_blend_operation_advanced") // 149 - VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, - - //@extension("VK_EXT_conditional_rendering") // 82 - VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, - - //@extension("VK_NV_shading_rate_image") // 165 - VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000, - - //@extension("VK_NV_ray_tracing") // 166 - VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000, - VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000, - - //@extension("VK_EXT_fragment_density_map") // 219 - VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, - - //@extension("VK_EXT_transform_feedback") // 29 - VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, - VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, - VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, -} - -/// Buffer usage flags -type VkFlags VkBufferUsageFlags -bitfield VkBufferUsageFlagBits { - VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, /// Can be used as a source of transfer operations - VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, /// Can be used as a destination of transfer operations - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, /// Can be used as TBO - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, /// Can be used as IBO - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, /// Can be used as UBO - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, /// Can be used as SSBO - VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, /// Can be used as source of fixed function index fetch (index buffer) - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, /// Can be used as source of fixed function vertex fetch (VBO) - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, /// Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) - - //@extension("VK_EXT_conditional_rendering") // 82 - VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, - - //@extension("VK_NV_ray_tracing") // 166 - VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400, - - //@extension("VK_EXT_transform_feedback") // 29 - VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, - VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, -} - -/// Buffer creation flags -type VkFlags VkBufferCreateFlags -bitfield VkBufferCreateFlagBits { - VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, /// Buffer should support sparse backing - VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Buffer should support sparse backing with partial residency - VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Buffer should support constent data access to physical memory blocks mapped into multiple locations of sparse buffers - - //@vulkan1_1 - VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, -} - -/// Shader stage flags -type VkFlags VkShaderStageFlags -bitfield VkShaderStageFlagBits { - VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, - VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, - VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, - VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, - VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, - - VK_SHADER_STAGE_ALL = 0x7FFFFFFF, - - //@extension("VK_NV_ray_tracing") // 166 - VK_SHADER_STAGE_RAYGEN_BIT_NV = 0x00000100, - VK_SHADER_STAGE_ANY_HIT_BIT_NV = 0x00000200, - VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = 0x00000400, - VK_SHADER_STAGE_MISS_BIT_NV = 0x00000800, - VK_SHADER_STAGE_INTERSECTION_BIT_NV = 0x00001000, - VK_SHADER_STAGE_CALLABLE_BIT_NV = 0x00002000, - - //@extension("VK_NV_mesh_shader") // 203 - VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040, - VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080, -} - -/// Descriptor pool create flags -type VkFlags VkDescriptorPoolCreateFlags -bitfield VkDescriptorPoolCreateFlagBits { - VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, - - //@extension("VK_EXT_descriptor_indexing") // 162 - VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002, -} - -/// Descriptor pool reset flags -type VkFlags VkDescriptorPoolResetFlags -//bitfield VkDescriptorPoolResetFlagBits { -//} - -/// Image usage flags -type VkFlags VkImageUsageFlags -bitfield VkImageUsageFlagBits { - VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, /// Can be used as a source of transfer operations - VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, /// Can be used as a destination of transfer operations - VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) - VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, /// Can be used as storage image (STORAGE_IMAGE descriptor type) - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, /// Can be used as framebuffer color attachment - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, /// Can be used as framebuffer depth/stencil attachment - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, /// Image data not needed outside of rendering - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, /// Can be used as framebuffer input attachment - - //@extension("VK_NV_shading_rate_image") // 165 - VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100, - - //@extension("VK_EXT_fragment_density_map") // 219 - VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, -} - -/// Image creation flags -type VkFlags VkImageCreateFlags -bitfield VkImageCreateFlagBits { - VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, /// Image should support sparse backing - VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Image should support sparse backing with partial residency - VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Image should support constent data access to physical memory blocks mapped into multiple locations of sparse images - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, /// Allows image views to have different format than the base image - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, /// Allows creating image views with cube type from the created image - - //@vulkan1_1 - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, - VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, - VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, - VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, - - //@extension("VK_KHR_maintenance1") // 70 - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020, - - //@extension("VK_KHR_device_group") // 61 - VK_IMAGE_CREATE_BIND_SFR_BIT_KHR = 0x00000040, - - //@extension("VK_KHR_maintenance2") // 118 - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = 0x00000100, - - //@extension("VK_KHR_sampler_ycbcr_conversion") // 157 - VK_IMAGE_CREATE_DISJOINT_BIT_KHR = 0x00000200, - - //@extension("VK_KHR_bind_memory2") // 158 - VK_IMAGE_CREATE_ALIAS_BIT_KHR = 0x00000400, - - //@extension("VK_EXT_sample_locations") // 144 - VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, - - //@extension("VK_NV_corner_sampled_image") // 51 - VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, - - //@extension("VK_EXT_fragment_density_map") // 219 - VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, -} - -/// Image view creation flags -type VkFlags VkImageViewCreateFlags -bitfield VkImageViewCreateFlagBits { - //@extension("VK_EXT_fragment_density_map") // 219 - VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, -} - -/// Pipeline creation flags -type VkFlags VkPipelineCreateFlags -bitfield VkPipelineCreateFlagBits { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, - - //@vulkan1_1 - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, - VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, - - //@extension("VK_KHR_device_group") // 61 - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008, - VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = 0x00000010, - - //@extension("VK_NV_ray_tracing") // 166 - VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, -} - -/// Color component flags -type VkFlags VkColorComponentFlags -bitfield VkColorComponentFlagBits { - VK_COLOR_COMPONENT_R_BIT = 0x00000001, - VK_COLOR_COMPONENT_G_BIT = 0x00000002, - VK_COLOR_COMPONENT_B_BIT = 0x00000004, - VK_COLOR_COMPONENT_A_BIT = 0x00000008, -} - -/// Fence creation flags -type VkFlags VkFenceCreateFlags -bitfield VkFenceCreateFlagBits { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, -} - -/// Semaphore creation flags -type VkFlags VkSemaphoreCreateFlags -//bitfield VkSemaphoreCreateFlagBits { -//} - -/// Format capability flags -type VkFlags VkFormatFeatureFlags -bitfield VkFormatFeatureFlagBits { - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, /// Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) - VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, /// Format can be used for storage images (STORAGE_IMAGE descriptor type) - VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, /// Format supports atomic operations in case it's used for storage images - VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, /// Format can be used for uniform texel buffers (TBOs) - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, /// Format can be used for storage texel buffers (IBOs) - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, /// Format supports atomic operations in case it's used for storage texel buffers - VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, /// Format can be used for vertex buffers (VBOs) - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, /// Format can be used for color attachment images - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, /// Format supports blending in case it's used for color attachment images - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, /// Format can be used for depth/stencil attachment images - VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, /// Format can be used as the source image of blits with vkCommandBlitImage - VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, /// Format can be used as the destination image of blits with vkCommandBlitImage - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, - - //@vulkan1_1 - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, - VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, - - //@extension("VK_IMG_filter_cubic") // 16 - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, - - //@extension("VK_KHR_maintenance1") // 70 - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000, - - //@extension("VK_EXT_sampler_filter_minmax") // 131 - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, - - //@extension("VK_KHR_sampler_ycbcr_conversion") // 157 - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000, - VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = 0x00400000, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000, -} - -/// Query control flags -type VkFlags VkQueryControlFlags -bitfield VkQueryControlFlagBits { - VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, -} - -/// Query result flags -type VkFlags VkQueryResultFlags -bitfield VkQueryResultFlagBits { - VK_QUERY_RESULT_64_BIT = 0x00000001, /// Results of the queries are written to the destination buffer as 64-bit values - VK_QUERY_RESULT_WAIT_BIT = 0x00000002, /// Results of the queries are waited on before proceeding with the result copy - VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, /// Besides the results of the query, the availability of the results is also written - VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, /// Copy the partial results of the query even if the final results aren't available -} - -/// Shader module creation flags -type VkFlags VkShaderModuleCreateFlags -//bitfield VkShaderModuleCreateFlagBits { -//} - -/// Event creation flags -type VkFlags VkEventCreateFlags -//bitfield VkEventCreateFlagBits { -//} - -/// Command buffer usage flags -type VkFlags VkCommandBufferUsageFlags -bitfield VkCommandBufferUsageFlagBits { - VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, - VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, - VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, -} - -/// Pipeline statistics flags -type VkFlags VkQueryPipelineStatisticFlags -bitfield VkQueryPipelineStatisticFlagBits { - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, /// Optional - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, /// Optional - VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, /// Optional - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, /// Optional - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, /// Optional - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, /// Optional - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, /// Optional - VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, /// Optional - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, /// Optional - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, /// Optional - VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, /// Optional -} - -/// Memory mapping flags -type VkFlags VkMemoryMapFlags -//bitfield VkMemoryMapFlagBits { -//} - -/// Bitfield of image aspects -type VkFlags VkImageAspectFlags -bitfield VkImageAspectFlagBits { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, - VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, - - //@vulkan1_1 - VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, - VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, - VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, - - //@extension("VK_KHR_sampler_ycbcr_conversion") // 157 - VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = 0x00000010, - VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = 0x00000020, - VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = 0x00000040, - - //@extension("VK_EXT_transform_feedback") // 29 - VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, - VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, - VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, - VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, -} - -/// Sparse memory bind flags -type VkFlags VkSparseMemoryBindFlags -bitfield VkSparseMemoryBindFlagBits { - VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, -} - -/// Sparse image memory requirements flags -type VkFlags VkSparseImageFormatFlags -bitfield VkSparseImageFormatFlagBits { - VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, /// Image uses a single miptail region for all array slices - VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels. - VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, /// Image uses a non-standard sparse block size -} - -/// Pipeline stages -type VkFlags VkPipelineStageFlags -bitfield VkPipelineStageFlagBits { - VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, /// Before subsequent commands are processed - VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, /// Draw/DispatchIndirect command fetch - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, /// Vertex/index fetch - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, /// Vertex shading - VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, /// Tessellation control shading - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, /// Tessellation evaluation shading - VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, /// Geometry shading - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, /// Fragment shading - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, /// Early fragment (depth/stencil) tests - VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, /// Late fragment (depth/stencil) tests - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, /// Color attachment writes - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, /// Compute shading - VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, /// Transfer/copy operations - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, - VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, /// Indicates host (CPU) is a source/sink of the dependency - - VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, /// All stages of the graphics pipeline - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, /// All graphics, compute, copy, and transition commands - - //@extension("VK_NVX_device_generated_commands") // 87 - VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, - - //@extension("VK_EXT_conditional_rendering") // 82 - VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, - - //@extension("VK_NV_mesh_shader") // 203 - VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, - VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, - - //@extension("VK_NV_ray_tracing") // 166 - VK_PIPELINE_STAGE_RAY_TRACING_BIT_NV = 0x00200000, - - //@extension("VK_NV_shading_rate_image") // 165 - VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000, - - //@extension("VK_EXT_fragment_density_map") // 219 - VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, - - //@extension("VK_EXT_transform_feedback") // 29 - VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, - - //@extension("VK_NV_ray_tracing") // 166 - VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000, -} - -/// Render pass attachment description flags -type VkFlags VkAttachmentDescriptionFlags -bitfield VkAttachmentDescriptionFlagBits { - VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, /// The attachment may alias physical memory of another attachment in the same renderpass -} - -/// Subpass description flags -type VkFlags VkSubpassDescriptionFlags -bitfield VkSubpassDescriptionFlagBits { - //@extension("VK_NVX_multiview_per_view_attributes") // 98 - VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, - VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, -} - -/// Command pool creation flags -type VkFlags VkCommandPoolCreateFlags -bitfield VkCommandPoolCreateFlagBits { - VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime - VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually - - //@vulkan1_1 - VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, -} - -/// Command pool reset flags -type VkFlags VkCommandPoolResetFlags -bitfield VkCommandPoolResetFlagBits { - VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the pool -} - -type VkFlags VkCommandBufferResetFlags -bitfield VkCommandBufferResetFlagBits { - VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the buffer -} - -type VkFlags VkSampleCountFlags -bitfield VkSampleCountFlagBits { - VK_SAMPLE_COUNT_1_BIT = 0x00000001, - VK_SAMPLE_COUNT_2_BIT = 0x00000002, - VK_SAMPLE_COUNT_4_BIT = 0x00000004, - VK_SAMPLE_COUNT_8_BIT = 0x00000008, - VK_SAMPLE_COUNT_16_BIT = 0x00000010, - VK_SAMPLE_COUNT_32_BIT = 0x00000020, - VK_SAMPLE_COUNT_64_BIT = 0x00000040, -} - -type VkFlags VkStencilFaceFlags -bitfield VkStencilFaceFlagBits { - VK_STENCIL_FACE_FRONT_BIT = 0x00000001, /// Front face - VK_STENCIL_FACE_BACK_BIT = 0x00000002, /// Back face - VK_STENCIL_FRONT_AND_BACK = 0x00000003, -} - -/// Instance creation flags -type VkFlags VkInstanceCreateFlags -//bitfield VkInstanceCreateFlagBits { -//} - -/// Device creation flags -type VkFlags VkDeviceCreateFlags -//bitfield VkDeviceCreateFlagBits { -//} - -/// Device queue creation flags -type VkFlags VkDeviceQueueCreateFlags -@vulkan1_1 -bitfield VkDeviceQueueCreateFlagBits { - VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, -} - -/// Query pool creation flags -type VkFlags VkQueryPoolCreateFlags -//bitfield VkQueryPoolCreateFlagBits { -//} - -/// Buffer view creation flags -type VkFlags VkBufferViewCreateFlags -//bitfield VkBufferViewCreateFlagBits { -//} - -/// Pipeline cache creation flags -type VkFlags VkPipelineCacheCreateFlags -//bitfield VkPipelineCacheCreateFlagBits { -//} - -/// Pipeline shader stage creation flags -type VkFlags VkPipelineShaderStageCreateFlags -//bitfield VkPipelineShaderStageCreateFlagBits { -//} - -/// Descriptor set layout creation flags -type VkFlags VkDescriptorSetLayoutCreateFlags -bitfield VkDescriptorSetLayoutCreateFlagBits { - //@extension("VK_KHR_push_descriptor") // 81 - VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, - - //@extension("VK_EXT_descriptor_indexing") // 162 - VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002, -} - -/// Pipeline vertex input state creation flags -type VkFlags VkPipelineVertexInputStateCreateFlags -//bitfield VkPipelineVertexInputStateCreateFlagBits { -//} - -/// Pipeline input assembly state creation flags -type VkFlags VkPipelineInputAssemblyStateCreateFlags -//bitfield VkPipelineInputAssemblyStateCreateFlagBits { -//} - -/// Tessellation state creation flags -type VkFlags VkPipelineTessellationStateCreateFlags -//bitfield VkPipelineTessellationStateCreateFlagBits { -//} - -/// Viewport state creation flags -type VkFlags VkPipelineViewportStateCreateFlags -//bitfield VkPipelineViewportStateCreateFlagBits { -//} - -/// Rasterization state creation flags -type VkFlags VkPipelineRasterizationStateCreateFlags -//bitfield VkPipelineRasterizationStateCreateFlagBits { -//} - -/// Multisample state creation flags -type VkFlags VkPipelineMultisampleStateCreateFlags -//bitfield VkPipelineMultisampleStateCreateFlagBits { -//} - -/// Color blend state creation flags -type VkFlags VkPipelineColorBlendStateCreateFlags -//bitfield VkPipelineColorBlendStateCreateFlagBits { -//} - -/// Depth/stencil state creation flags -type VkFlags VkPipelineDepthStencilStateCreateFlags -//bitfield VkPipelineDepthStencilStateCreateFlagBits { -//} - -/// Dynamic state creation flags -type VkFlags VkPipelineDynamicStateCreateFlags -//bitfield VkPipelineDynamicStateCreateFlagBits { -//} - -/// Pipeline layout creation flags -type VkFlags VkPipelineLayoutCreateFlags -//bitfield VkPipelineLayoutCreateFlagBits { -//} - -/// Sampler creation flags -type VkFlags VkSamplerCreateFlags -bitfield VkSamplerCreateFlagBits { - //@extension("VK_EXT_fragment_density_map") // 219 - VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, - VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, -} - -/// Render pass creation flags -type VkFlags VkRenderPassCreateFlags -//bitfield VkRenderPassCreateFlagBits { -//} - -/// Framebuffer creation flags -type VkFlags VkFramebufferCreateFlags -//bitfield VkFramebufferCreateFlagBits { -//} - -/// Dependency flags -type VkFlags VkDependencyFlags -bitfield VkDependencyFlagBits { - VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, - - //@vulkan1_1 - VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, - VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, - - //@extension("VK_KHR_multiview") // 54 - VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = 0x00000002, - - //@extension("VK_KHR_device_group") // 61 - VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = 0x00000004, -} - -/// Cull mode flags -type VkFlags VkCullModeFlags -bitfield VkCullModeFlagBits { - VK_CULL_MODE_NONE = 0x00000000, - VK_CULL_MODE_FRONT_BIT = 0x00000001, - VK_CULL_MODE_BACK_BIT = 0x00000002, - VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, -} - -//@vulkan1_1 flags - -/// Subgroup feature flags -type VkFlags VkSubgroupFeatureFlags -bitfield VkSubgroupFeatureFlagBits { - VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, - VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, - VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, - VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, - VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, - VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, - VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, - VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, - - //@extension("VK_NV_shader_subgroup_partitioned") // 199 - VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, -} - -/// Peer memory feature flags -type VkFlags VkPeerMemoryFeatureFlags -bitfield VkPeerMemoryFeatureFlagBits { - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, -} - -/// Memory allocation flags -type VkFlags VkMemoryAllocateFlags -bitfield VkMemoryAllocateFlagBits { - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, -} - -type VkFlags VkCommandPoolTrimFlags -//bitfield VkCommandPoolTrimFlagBits { -//} - -type VkFlags VkDescriptorUpdateTemplateCreateFlags -//bitfield VkDescriptorUpdateTemplateCreateFlagBits { -//} - -/// External memory handle type flags -type VkFlags VkExternalMemoryHandleTypeFlags -bitfield VkExternalMemoryHandleTypeFlagBits { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, - - //@extension("VK_EXT_external_memory_host") // 179 - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, - - //@extension("VK_EXT_external_memory_dma_buf") // 126 - VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, - - //@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 - VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, -} - -/// External memory feature flags -type VkFlags VkExternalMemoryFeatureFlags -bitfield VkExternalMemoryFeatureFlagBits { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, -} - -/// External fence handle type flags -type VkFlags VkExternalFenceHandleTypeFlags -bitfield VkExternalFenceHandleTypeFlagBits { - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, -} - -/// External fence feature flags -type VkFlags VkExternalFenceFeatureFlags -bitfield VkExternalFenceFeatureFlagBits { - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, -} - -/// Fence import flags -type VkFlags VkFenceImportFlags -bitfield VkFenceImportFlagBits { - VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, -} - -/// Semaphore import flags -type VkFlags VkSemaphoreImportFlags -bitfield VkSemaphoreImportFlagBits { - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, -} - -/// External semaphore handle type flags -type VkFlags VkExternalSemaphoreHandleTypeFlags -bitfield VkExternalSemaphoreHandleTypeFlagBits { - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, -} - -/// External semaphore feature flags -type VkFlags VkExternalSemaphoreFeatureFlags -bitfield VkExternalSemaphoreFeatureFlagBits { - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, -} - -@extension("VK_KHR_surface") // 1 -type VkFlags VkSurfaceTransformFlagsKHR -@extension("VK_KHR_surface") // 1 -bitfield VkSurfaceTransformFlagBitsKHR { - VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, -} - -@extension("VK_KHR_surface") // 1 -type VkFlags VkCompositeAlphaFlagsKHR -@extension("VK_KHR_surface") // 1 -bitfield VkCompositeAlphaFlagBitsKHR { - VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, -} - -@extension("VK_KHR_swapchain") // 2 -type VkFlags VkSwapchainCreateFlagsKHR -@extension("VK_KHR_swapchain") // 2 -bitfield VkSwapchainCreateFlagBitsKHR { - //@vulkan1_1 - VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, - VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, - - //@extension("VK_KHR_swapchain_mutable_format") // 201 - VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -type VkFlags VkDeviceGroupPresentModeFlagsKHR -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -bitfield VkDeviceGroupPresentModeFlagBitsKHR { - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, - VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, - VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, -} - -@extension("VK_KHR_display") // 3 -type VkFlags VkDisplayPlaneAlphaFlagsKHR -@extension("VK_KHR_display") // 3 -bitfield VkDisplayPlaneAlphaFlagBitsKHR { - VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, -} - -@extension("VK_KHR_display") // 3 -type VkFlags VkDisplaySurfaceCreateFlagsKHR -//@extension("VK_KHR_display") // 3 -//bitfield VkDisplaySurfaceCreateFlagBitsKHR { -//} - -@extension("VK_KHR_display") // 3 -type VkFlags VkDisplayModeCreateFlagsKHR -//@extension("VK_KHR_display") // 3 -//bitfield VkDisplayModeCreateFlagBitsKHR { -//} - -@extension("VK_KHR_xlib_surface") // 5 -type VkFlags VkXlibSurfaceCreateFlagsKHR -//@extension("VK_KHR_xlib_surface") // 5 -//bitfield VkXlibSurfaceCreateFlagBitsKHR { -//} - -@extension("VK_KHR_xcb_surface") // 6 -type VkFlags VkXcbSurfaceCreateFlagsKHR -//@extension("VK_KHR_xcb_surface") // 6 -//bitfield VkXcbSurfaceCreateFlagBitsKHR { -//} - -@extension("VK_KHR_wayland_surface") // 7 -type VkFlags VkWaylandSurfaceCreateFlagsKHR -//@extension("VK_KHR_wayland_surface") // 7 -//bitfield VkWaylandSurfaceCreateFlagBitsKHR { -//} - -@extension("VK_KHR_android_surface") // 9 -type VkFlags VkAndroidSurfaceCreateFlagsKHR -//@extension("VK_KHR_android_surface") // 9 -//bitfield VkAndroidSurfaceCreateFlagBitsKHR { -//} - -@extension("VK_KHR_win32_surface") // 10 -type VkFlags VkWin32SurfaceCreateFlagsKHR -//@extension("VK_KHR_win32_surface") // 10 -//bitfield VkWin32SurfaceCreateFlagBitsKHR { -//} - -@extension("VK_ANDROID_native_buffer") // 11 -type VkFlags VkSwapchainImageUsageFlagsANDROID -@extension("VK_ANDROID_native_buffer") // 11 -bitfield VkSwapchainImageUsageFlagBitsANDROID { - VK_SWAPCHAIN_IMAGE_USAGE_FLAGS_SHARED_BIT_ANDROID = 0x00000001, -} - -@extension("VK_EXT_debug_report") // 12 -type VkFlags VkDebugReportFlagsEXT -@extension("VK_EXT_debug_report") // 12 -bitfield VkDebugReportFlagBitsEXT { - VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, - VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, - VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, - VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, - VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, -} - -@extension("VK_EXT_transform_feedback") // 29 -type VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT -//@extension("VK_EXT_transform_feedback") // 29 -//bitfield VkPipelineRasterizationStateStreamCreateFlagBitsEXT { -//} - -@extension("VK_NV_external_memory_capabilities") // 56 -type VkFlags VkExternalMemoryHandleTypeFlagsNV -@extension("VK_NV_external_memory_capabilities") // 56 -bitfield VkExternalMemoryHandleTypeFlagBitsNV { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, -} - -@extension("VK_NV_external_memory_capabilities") // 56 -type VkFlags VkExternalMemoryFeatureFlagsNV -@extension("VK_NV_external_memory_capabilities") // 56 -bitfield VkExternalMemoryFeatureFlagBitsNV { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, -} - -@extension("VK_KHR_device_group") // 61 -type VkFlags VkPeerMemoryFeatureFlagsKHR -@extension("VK_KHR_device_group") // 61 -bitfield VkPeerMemoryFeatureFlagBitsKHR { - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = 0x00000001, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = 0x00000002, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = 0x00000004, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = 0x00000008, -} - -@extension("VK_KHR_device_group") // 61 -type VkFlags VkMemoryAllocateFlagsKHR -@extension("VK_KHR_device_group") // 61 -bitfield VkMemoryAllocateFlagBitsKHR { - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = 0x00000001, -} - -@extension("VK_NN_vi_surface") // 63 -type VkFlags VkViSurfaceCreateFlagsNN -//@extension("VK_NN_vi_surface") // 63 -//bitfield VkViSurfaceCreateFlagBitsNN { -//} - -@extension("VK_KHR_maintenance1") // 70 -type VkFlags VkCommandPoolTrimFlagsKHR -//@extension("VK_KHR_maintenance1") // 70 -//bitfield VkCommandPoolTrimFlagBitsKHR { -//} - -@extension("VK_KHR_external_memory_capabilities") // 72 -type VkFlags VkExternalMemoryHandleTypeFlagsKHR -@extension("VK_KHR_external_memory_capabilities") // 72 -bitfield VkExternalMemoryHandleTypeFlagBitsKHR { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040, -} - -@extension("VK_KHR_external_memory_capabilities") // 72 -type VkFlags VkExternalMemoryFeatureFlagsKHR -@extension("VK_KHR_external_memory_capabilities") // 72 -bitfield VkExternalMemoryFeatureFlagBitsKHR { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004, -} - -@extension("VK_KHR_external_semaphore_capabilities") // 77 -type VkFlags VkExternalSemaphoreHandleTypeFlagsKHR -@extension("VK_KHR_external_semaphore_capabilities") // 77 -bitfield VkExternalSemaphoreHandleTypeFlagBitsKHR { - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001 - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002 - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004 - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008 - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHR = 0x00000010 -} - -@extension("VK_KHR_external_semaphore_capabilities") // 77 -type VkFlags VkExternalSemaphoreFeatureFlagsKHR -@extension("VK_KHR_external_semaphore_capabilities") // 77 -bitfield VkExternalSemaphoreFeatureFlagBitsKHR { - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, -} - -@extension("VK_KHR_external_semaphore") // 78 -type VkFlags VkSemaphoreImportFlagsKHR -@extension("VK_KHR_external_semaphore") // 78 -bitfield VkSemaphoreImportFlagBitsKHR { - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, -} - -@extension("VK_EXT_conditional_rendering") // 82 -type VkFlags VkConditionalRenderingFlagsEXT -@extension("VK_EXT_conditional_rendering") // 82 -bitfield VkConditionalRenderingFlagBitsEXT { - VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, -} - -@extension("VK_KHR_descriptor_update_template") // 86 -type VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR -//@extension("VK_KHR_descriptor_update_template") // 86 -//bitfield VkDescriptorUpdateTemplateCreateFlagBitsKHR { -//} - -@extension("VK_NVX_device_generated_commands") // 87 -type VkFlags VkIndirectCommandsLayoutUsageFlagsNVX -@extension("VK_NVX_device_generated_commands") // 87 -bitfield VkIndirectCommandsLayoutUsageFlagBitsNVX { - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, -} - -@extension("VK_NVX_device_generated_commands") // 87 -type VkFlags VkObjectEntryUsageFlagsNVX -@extension("VK_NVX_device_generated_commands") // 87 -bitfield VkObjectEntryUsageFlagBitsNVX { - VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, - VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, -} - -@extension("VK_EXT_display_surface_counter") // 91 -type VkFlags VkSurfaceCounterFlagsEXT -@extension("VK_EXT_display_surface_counter") // 91 -bitfield VkSurfaceCounterFlagBitsEXT { - VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001, -} - -@extension("VK_NV_viewport_swizzle") // 99 -type VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV -//@extension("VK_NV_viewport_swizzle") // 99 -//bitfield VkPipelineViewportSwizzleStateCreateFlagBitsNV { -//} - -@extension("VK_EXT_discard_rectangles") // 100 -type VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT -//@extension("VK_EXT_discard_rectangles") // 100 -//bitfield VkPipelineDiscardRectangleStateCreateFlagBitsEXT { -//} - -@extension("VK_EXT_conservative_rasterization") // 102 -type VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT -//@extension("VK_EXT_conservative_rasterization") // 102 -//bitfield VkPipelineRasterizationConservativeStateCreateFlagBitsEXT { -//} - -@extension("VK_KHR_external_fence_capabilities") // 113 -type VkFlags VkExternalFenceHandleTypeFlagsKHR -@extension("VK_KHR_external_fence_capabilities") // 113 -bitfield VkExternalFenceHandleTypeFlagBitsKHR { - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008, -} - -@extension("VK_KHR_external_fence_capabilities") // 113 -type VkFlags VkExternalFenceFeatureFlagsKHR -@extension("VK_KHR_external_fence_capabilities") // 113 -bitfield VkExternalFenceFeatureFlagBitsKHR { - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, -} - -@extension("VK_KHR_external_fence") // 114 -type VkFlags VkFenceImportFlagsKHR -@extension("VK_KHR_external_fence") // 114 -bitfield VkFenceImportFlagBitsKHR { - VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, -} - -@extension("VK_MVK_ios_surface") // 123 -type VkFlags VkIOSSurfaceCreateFlagsMVK -//@extension("VK_MVK_ios_surface") // 123 -//bitfield VkIOSSurfaceCreateFlagBitsMVK { -//} - -@extension("VK_MVK_macos_surface") // 124 -type VkFlags VkMacOSSurfaceCreateFlagsMVK -//@extension("VK_MVK_macos_surface") // 124 -//bitfield VkMacOSSurfaceCreateFlagBitsMVK { -//} - -@extension("VK_EXT_debug_utils") // 129 -type VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT -//@extension("VK_EXT_debug_utils") // 129 -//bitfield VkDebugUtilsMessengerCallbackDataFlagBitsEXT { -//} - -@extension("VK_EXT_debug_utils") // 129 -type VkFlags VkDebugUtilsMessengerCreateFlagsEXT -//@extension("VK_EXT_debug_utils") // 129 -//bitfield VkDebugUtilsMessengerCreateFlagBitsEXT { -//} - -@extension("VK_EXT_debug_utils") // 129 -type VkFlags VkDebugUtilsMessageSeverityFlagsEXT -@extension("VK_EXT_debug_utils") // 129 -bitfield VkDebugUtilsMessageSeverityFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, -} - -@extension("VK_EXT_debug_utils") // 129 -type VkFlags VkDebugUtilsMessageTypeFlagsEXT -@extension("VK_EXT_debug_utils") // 129 -bitfield VkDebugUtilsMessageTypeFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, - VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, -} - -@extension("VK_NV_fragment_coverage_to_color") // 150 -type VkFlags VkPipelineCoverageToColorStateCreateFlagsNV -@extension("VK_NV_fragment_coverage_to_color") // 150 -//bitfield VkPipelineCoverageToColorStateCreateFlagBitsNV { -//} - -@extension("VK_NV_framebuffer_mixed_samples") // 153 -type VkFlags VkPipelineCoverageModulationStateCreateFlagsNV -@extension("VK_NV_framebuffer_mixed_samples") // 153 -//bitfield VkPipelineCoverageModulationStateCreateFlagBitsNV { -//} - -@extension("VK_EXT_validation_cache") // 161 -type VkFlags VkValidationCacheCreateFlagsEXT -@extension("VK_EXT_validation_cache") // 161 -//bitfield VkValidationCacheCreateFlagBitsEXT { -//} - -@extension("VK_EXT_descriptor_indexing") // 162 -type VkFlags VkDescriptorBindingFlagsEXT -@extension("VK_EXT_descriptor_indexing") // 162 -bitfield VkDescriptorBindingFlagBitsEXT { - VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = 0x00000001, - VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = 0x00000002, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = 0x00000004, - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = 0x00000008, -} - -@extension("VK_NV_ray_tracing") // 166 -type VkFlags VkGeometryFlagsNV -@extension("VK_NV_ray_tracing") // 166 -bitfield VkGeometryFlagBitsNV { - VK_GEOMETRY_OPAQUE_BIT_NV = 0x00000001, - VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = 0x00000002, -} - -@extension("VK_NV_ray_tracing") // 166 -type VkFlags VkGeometryInstanceFlagsNV -@extension("VK_NV_ray_tracing") // 166 -bitfield VkGeometryInstanceFlagBitsNV { - VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = 0x00000001, - VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = 0x00000002, - VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = 0x00000004, - VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = 0x00000008, -} - -@extension("VK_NV_ray_tracing") // 166 -type VkFlags VkBuildAccelerationStructureFlagsNV -@extension("VK_NV_ray_tracing") // 166 -bitfield VkBuildAccelerationStructureFlagBitsNV { - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = 0x00000001, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = 0x00000002, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = 0x00000004, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = 0x00000008, - VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = 0x00000010, -} - -@extension("VK_FUCHSIA_imagepipe_surface") // 215 -type VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA -//@extension("VK_FUCHSIA_imagepipe_surface") // 215 -//bitfield VkImagePipeSurfaceCreateFlagBitsFUCHSIA { -//} - -////////////////// -// Structures // -////////////////// - -class VkOffset2D { - s32 x - s32 y -} - -class VkOffset3D { - s32 x - s32 y - s32 z -} - -class VkExtent2D { - u32 width - u32 height -} - -class VkExtent3D { - u32 width - u32 height - u32 depth -} - -class VkViewport { - f32 x - f32 y - f32 width - f32 height - f32 minDepth - f32 maxDepth -} - -class VkRect2D { - VkOffset2D offset - VkExtent2D extent -} - -class VkClearRect { - VkRect2D rect - u32 baseArrayLayer - u32 layerCount -} - -class VkComponentMapping { - VkComponentSwizzle r - VkComponentSwizzle g - VkComponentSwizzle b - VkComponentSwizzle a -} - -class VkPhysicalDeviceProperties { - u32 apiVersion - u32 driverVersion - u32 vendorID - u32 deviceID - VkPhysicalDeviceType deviceType - char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] deviceName - u8[VK_UUID_SIZE] pipelineCacheUUID - VkPhysicalDeviceLimits limits - VkPhysicalDeviceSparseProperties sparseProperties -} - -class VkExtensionProperties { - char[VK_MAX_EXTENSION_NAME_SIZE] extensionName /// extension name - u32 specVersion /// version of the extension specification implemented -} - -class VkLayerProperties { - char[VK_MAX_EXTENSION_NAME_SIZE] layerName /// layer name - u32 specVersion /// version of the layer specification implemented - u32 implementationVersion /// build or release version of the layer's library - char[VK_MAX_DESCRIPTION_SIZE] description /// Free-form description of the layer -} - -class VkSubmitInfo { - VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_SUBMIT_INFO - const void* pNext /// Next structure in chain - u32 waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - const VkPipelineStageFlags* pWaitDstStageMask - u32 commandBufferCount - const VkCommandBuffer* pCommandBuffers - u32 signalSemaphoreCount - const VkSemaphore* pSignalSemaphores -} - -class VkApplicationInfo { - VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO - const void* pNext /// Next structure in chain - const char* pApplicationName - u32 applicationVersion - const char* pEngineName - u32 engineVersion - u32 apiVersion -} - -class VkAllocationCallbacks { - void* pUserData - PFN_vkAllocationFunction pfnAllocation - PFN_vkReallocationFunction pfnReallocation - PFN_vkFreeFunction pfnFree - PFN_vkInternalAllocationNotification pfnInternalAllocation - PFN_vkInternalFreeNotification pfnInternalFree -} - -class VkDeviceQueueCreateInfo { - VkStructureType sStype /// Should be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkDeviceQueueCreateFlags flags - u32 queueFamilyIndex - u32 queueCount - const f32* pQueuePriorities -} - -class VkDeviceCreateInfo { - VkStructureType sType /// Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkDeviceCreateFlags flags - u32 queueCreateInfoCount - const VkDeviceQueueCreateInfo* pQueueCreateInfos - u32 enabledLayerCount - const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled - u32 enabledExtensionCount - const char* const* ppEnabledExtensionNames - const VkPhysicalDeviceFeatures* pEnabledFeatures -} - -class VkInstanceCreateInfo { - VkStructureType sType /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkInstanceCreateFlags flags - const VkApplicationInfo* pApplicationInfo - u32 enabledLayerCount - const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled - u32 enabledExtensionCount - const char* const* ppEnabledExtensionNames /// Extension names to be enabled -} - -class VkQueueFamilyProperties { - VkQueueFlags queueFlags /// Queue flags - u32 queueCount - u32 timestampValidBits - VkExtent3D minImageTransferGranularity -} - -class VkPhysicalDeviceMemoryProperties { - u32 memoryTypeCount - VkMemoryType[VK_MAX_MEMORY_TYPES] memoryTypes - u32 memoryHeapCount - VkMemoryHeap[VK_MAX_MEMORY_HEAPS] memoryHeaps -} - -class VkMemoryAllocateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO - const void* pNext /// Pointer to next structure - VkDeviceSize allocationSize /// Size of memory allocation - u32 memoryTypeIndex /// Index of the of the memory type to allocate from -} - -class VkMemoryRequirements { - VkDeviceSize size /// Specified in bytes - VkDeviceSize alignment /// Specified in bytes - u32 memoryTypeBits /// Bitfield of the allowed memory type indices into memoryTypes[] for this object -} - -class VkSparseImageFormatProperties { - VkImageAspectFlagBits aspectMask - VkExtent3D imageGranularity - VkSparseImageFormatFlags flags -} - -class VkSparseImageMemoryRequirements { - VkSparseImageFormatProperties formatProperties - u32 imageMipTailFirstLod - VkDeviceSize imageMipTailSize /// Specified in bytes, must be a multiple of image block size / alignment - VkDeviceSize imageMipTailOffset /// Specified in bytes, must be a multiple of image block size / alignment - VkDeviceSize imageMipTailStride /// Specified in bytes, must be a multiple of image block size / alignment -} - -class VkMemoryType { - VkMemoryPropertyFlags propertyFlags /// Memory properties of this memory type - u32 heapIndex /// Index of the memory heap allocations of this memory type are taken from -} - -class VkMemoryHeap { - VkDeviceSize size /// Available memory in the heap - VkMemoryHeapFlags flags /// Flags for the heap -} - -class VkMappedMemoryRange { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE - const void* pNext /// Pointer to next structure - VkDeviceMemory memory /// Mapped memory object - VkDeviceSize offset /// Offset within the mapped memory the range starts from - VkDeviceSize size /// Size of the range within the mapped memory -} - -class VkFormatProperties { - VkFormatFeatureFlags linearTilingFeatures /// Format features in case of linear tiling - VkFormatFeatureFlags optimalTilingFeatures /// Format features in case of optimal tiling - VkFormatFeatureFlags bufferFeatures /// Format features supported by buffers -} - -class VkImageFormatProperties { - VkExtent3D maxExtent /// max image dimensions for this resource type - u32 maxMipLevels /// max number of mipmap levels for this resource type - u32 maxArrayLayers /// max array layers for this resource type - VkSampleCountFlags sampleCounts /// supported sample counts for this resource type - VkDeviceSize maxResourceSize /// max size (in bytes) of this resource type -} - -class VkDescriptorImageInfo { - VkSampler sampler - VkImageView imageView - VkImageLayout imageLayout -} - -class VkDescriptorBufferInfo { - VkBuffer buffer /// Buffer used for this descriptor when the descriptor is UNIFORM_BUFFER[_DYNAMIC] - VkDeviceSize offset /// Base offset from buffer start in bytes to update in the descriptor set. - VkDeviceSize range /// Size in bytes of the buffer resource for this descriptor update. -} - -class VkWriteDescriptorSet { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET - const void* pNext /// Pointer to next structure - VkDescriptorSet dstSet /// Destination descriptor set - u32 dstBinding /// Binding within the destination descriptor set to write - u32 dstArrayElement /// Array element within the destination binding to write - u32 descriptorCount /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>) - VkDescriptorType descriptorType /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used) - const VkDescriptorImageInfo* pImageInfo - const VkDescriptorBufferInfo* pBufferInfo - const VkBufferView* pTexelBufferView -} - -class VkCopyDescriptorSet { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET - const void* pNext /// Pointer to next structure - VkDescriptorSet srcSet /// Source descriptor set - u32 srcBinding /// Binding within the source descriptor set to copy from - u32 srcArrayElement /// Array element within the source binding to copy from - VkDescriptorSet dstSet /// Destination descriptor set - u32 dstBinding /// Binding within the destination descriptor set to copy to - u32 dstArrayElement /// Array element within the destination binding to copy to - u32 descriptorCount /// Number of descriptors to copy -} - -class VkBufferCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO - const void* pNext /// Pointer to next structure. - VkBufferCreateFlags flags /// Buffer creation flags - VkDeviceSize size /// Specified in bytes - VkBufferUsageFlags usage /// Buffer usage flags - VkSharingMode sharingMode - u32 queueFamilyIndexCount - const u32* pQueueFamilyIndices -} - -class VkBufferViewCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO - const void* pNext /// Pointer to next structure. - VkBufferViewCreateFlags flags - VkBuffer buffer - VkFormat format /// Optionally specifies format of elements - VkDeviceSize offset /// Specified in bytes - VkDeviceSize range /// View size specified in bytes -} - -class VkImageSubresource { - VkImageAspectFlagBits aspectMask - u32 mipLevel - u32 arrayLayer -} - -class VkImageSubresourceRange { - VkImageAspectFlags aspectMask - u32 baseMipLevel - u32 levelCount - u32 baseArrayLayer - u32 layerCount -} - -class VkMemoryBarrier { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER - const void* pNext /// Pointer to next structure. - VkAccessFlags srcAccessMask - VkAccessFlags dstAccessMask -} - -class VkBufferMemoryBarrier { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER - const void* pNext /// Pointer to next structure. - VkAccessFlags srcAccessMask - VkAccessFlags dstAccessMask - u32 srcQueueFamilyIndex /// Queue family to transition ownership from - u32 dstQueueFamilyIndex /// Queue family to transition ownership to - VkBuffer buffer /// Buffer to sync - VkDeviceSize offset /// Offset within the buffer to sync - VkDeviceSize size /// Amount of bytes to sync -} - -class VkImageMemoryBarrier { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER - const void* pNext /// Pointer to next structure. - VkAccessFlags srcAccessMask - VkAccessFlags dstAccessMask - VkImageLayout oldLayout /// Current layout of the image - VkImageLayout newLayout /// New layout to transition the image to - u32 srcQueueFamilyIndex /// Queue family to transition ownership from - u32 dstQueueFamilyIndex /// Queue family to transition ownership to - VkImage image /// Image to sync - VkImageSubresourceRange subresourceRange /// Subresource range to sync -} - -class VkImageCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO - const void* pNext /// Pointer to next structure. - VkImageCreateFlags flags /// Image creation flags - VkImageType imageType - VkFormat format - VkExtent3D extent - u32 mipLevels - u32 arrayLayers - VkSampleCountFlagBits samples - VkImageTiling tiling - VkImageUsageFlags usage /// Image usage flags - VkSharingMode sharingMode /// Cross-queue-family sharing mode - u32 queueFamilyIndexCount /// Number of queue families to share across - const u32* pQueueFamilyIndices /// Array of queue family indices to share across - VkImageLayout initialLayout /// Initial image layout for all subresources -} - -class VkSubresourceLayout { - VkDeviceSize offset /// Specified in bytes - VkDeviceSize size /// Specified in bytes - VkDeviceSize rowPitch /// Specified in bytes - VkDeviceSize arrayPitch /// Specified in bytes - VkDeviceSize depthPitch /// Specified in bytes -} - -class VkImageViewCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO - const void* pNext /// Pointer to next structure - VkImageViewCreateFlags flags - VkImage image - VkImageViewType viewType - VkFormat format - VkComponentMapping components - VkImageSubresourceRange subresourceRange -} - -class VkBufferCopy { - VkDeviceSize srcOffset /// Specified in bytes - VkDeviceSize dstOffset /// Specified in bytes - VkDeviceSize size /// Specified in bytes -} - -class VkSparseMemoryBind { - VkDeviceSize resourceOffset /// Specified in bytes - VkDeviceSize size /// Specified in bytes - VkDeviceMemory memory - VkDeviceSize memoryOffset /// Specified in bytes - VkSparseMemoryBindFlags flags -} - -class VkSparseImageMemoryBind { - VkImageSubresource subresource - VkOffset3D offset - VkExtent3D extent - VkDeviceMemory memory - VkDeviceSize memoryOffset /// Specified in bytes - VkSparseMemoryBindFlags flags -} - -class VkSparseBufferMemoryBindInfo { - VkBuffer buffer - u32 bindCount - const VkSparseMemoryBind* pBinds -} - -class VkSparseImageOpaqueMemoryBindInfo { - VkImage image - u32 bindCount - const VkSparseMemoryBind* pBinds -} - -class VkSparseImageMemoryBindInfo { - VkImage image - u32 bindCount - const VkSparseMemoryBind* pBinds -} - -class VkBindSparseInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO - const void* pNext - u32 waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - u32 numBufferBinds - const VkSparseBufferMemoryBindInfo* pBufferBinds - u32 numImageOpaqueBinds - const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds - u32 numImageBinds - const VkSparseImageMemoryBindInfo* pImageBinds - u32 signalSemaphoreCount - const VkSemaphore* pSignalSemaphores -} - -class VkImageSubresourceLayers { - VkImageAspectFlags aspectMask - u32 mipLevel - u32 baseArrayLayer - u32 layerCount -} - -class VkImageCopy { - VkImageSubresourceLayers srcSubresource - VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images - VkImageSubresourceLayers dstSubresource - VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images - VkExtent3D extent /// Specified in pixels for both compressed and uncompressed images -} - -class VkImageBlit { - VkImageSubresourceLayers srcSubresource - VkOffset3D[2] srcOffsets - VkImageSubresourceLayers dstSubresource - VkOffset3D[2] dstOffsets -} - -class VkBufferImageCopy { - VkDeviceSize bufferOffset /// Specified in bytes - u32 bufferRowLength /// Specified in texels - u32 bufferImageHeight - VkImageSubresourceLayers imageSubresource - VkOffset3D imageOffset /// Specified in pixels for both compressed and uncompressed images - VkExtent3D imageExtent /// Specified in pixels for both compressed and uncompressed images -} - -class VkImageResolve { - VkImageSubresourceLayers srcSubresource - VkOffset3D srcOffset - VkImageSubresourceLayers dstSubresource - VkOffset3D dstOffset - VkExtent3D extent -} - -class VkShaderModuleCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkShaderModuleCreateFlags flags /// Reserved - platform.size_t codeSize /// Specified in bytes - const u32* pCode /// Binary code of size codeSize -} - -class VkDescriptorSetLayoutBinding { - u32 binding - VkDescriptorType descriptorType /// Type of the descriptors in this binding - u32 descriptorCount /// Number of descriptors in this binding - VkShaderStageFlags stageFlags /// Shader stages this binding is visible to - const VkSampler* pImmutableSamplers /// Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains <count> number of elements) -} - -class VkDescriptorSetLayoutCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO - const void* pNext /// Pointer to next structure - VkDescriptorSetLayoutCreateFlags flags - u32 bindingCount /// Number of bindings in the descriptor set layout - const VkDescriptorSetLayoutBinding* pBindings /// Array of descriptor set layout bindings -} - -class VkDescriptorPoolSize { - VkDescriptorType type - u32 descriptorCount -} - -class VkDescriptorPoolCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO - const void* pNext /// Pointer to next structure - VkDescriptorPoolCreateFlags flags - u32 maxSets - u32 poolSizeCount - const VkDescriptorPoolSize* pPoolSizes -} - -class VkDescriptorSetAllocateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO - const void* pNext /// Pointer to next structure - VkDescriptorPool descriptorPool - u32 setCount - const VkDescriptorSetLayout* pSetLayouts -} - -class VkSpecializationMapEntry { - u32 constantID /// The SpecConstant ID specified in the BIL - u32 offset /// Offset of the value in the data block - platform.size_t size /// Size in bytes of the SpecConstant -} - -class VkSpecializationInfo { - u32 mapEntryCount /// Number of entries in the map - const VkSpecializationMapEntry* pMapEntries /// Array of map entries - platform.size_t dataSize /// Size in bytes of pData - const void* pData /// Pointer to SpecConstant data -} - -class VkPipelineShaderStageCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineShaderStageCreateFlags flags - VkShaderStageFlagBits stage - VkShaderModule module - const char* pName - const VkSpecializationInfo* pSpecializationInfo -} - -class VkComputePipelineCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineCreateFlags flags /// Pipeline creation flags - VkPipelineShaderStageCreateInfo stage - VkPipelineLayout layout /// Interface layout of the pipeline - VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of - s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of -} - -class VkVertexInputBindingDescription { - u32 binding /// Vertex buffer binding id - u32 stride /// Distance between vertices in bytes (0 = no advancement) - VkVertexInputRate inputRate /// Rate at which binding is incremented -} - -class VkVertexInputAttributeDescription { - u32 location /// location of the shader vertex attrib - u32 binding /// Vertex buffer binding id - VkFormat format /// format of source data - u32 offset /// Offset of first element in bytes from base of vertex -} - -class VkPipelineVertexInputStateCreateInfo { - VkStructureType sType /// Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineVertexInputStateCreateFlags flags - u32 vertexBindingDescriptionCount /// number of bindings - const VkVertexInputBindingDescription* pVertexBindingDescriptions - u32 vertexAttributeDescriptionCount /// number of attributes - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions -} - -class VkPipelineInputAssemblyStateCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineInputAssemblyStateCreateFlags flags - VkPrimitiveTopology topology - VkBool32 primitiveRestartEnable -} - -class VkPipelineTessellationStateCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineTessellationStateCreateFlags flags - u32 patchControlPoints -} - -class VkPipelineViewportStateCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineViewportStateCreateFlags flags - u32 viewportCount - const VkViewport* pViewports - u32 scissorCount - const VkRect2D* pScissors -} - -class VkPipelineRasterizationStateCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineRasterizationStateCreateFlags flags - VkBool32 depthClampEnable - VkBool32 rasterizerDiscardEnable - VkPolygonMode polygonMode /// optional (GL45) - VkCullModeFlags cullMode - VkFrontFace frontFace - VkBool32 depthBiasEnable - f32 depthBiasConstantFactor - f32 depthBiasClamp - f32 depthBiasSlopeFactor - f32 lineWidth -} - -class VkPipelineMultisampleStateCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineMultisampleStateCreateFlags flags - VkSampleCountFlagBits rasterizationSamples /// Number of samples used for rasterization - VkBool32 sampleShadingEnable /// optional (GL45) - f32 minSampleShading /// optional (GL45) - const VkSampleMask* pSampleMask - VkBool32 alphaToCoverageEnable - VkBool32 alphaToOneEnable -} - -class VkPipelineColorBlendAttachmentState { - VkBool32 blendEnable - VkBlendFactor srcColorBlendFactor - VkBlendFactor dstColorBlendFactor - VkBlendOp colorBlendOp - VkBlendFactor srcAlphaBlendFactor - VkBlendFactor dstAlphaBlendFactor - VkBlendOp alphaBlendOp - VkColorComponentFlags colorWriteMask -} - -class VkPipelineColorBlendStateCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineColorBlendStateCreateFlags flags - VkBool32 logicOpEnable - VkLogicOp logicOp - u32 attachmentCount /// # of pAttachments - const VkPipelineColorBlendAttachmentState* pAttachments - f32[4] blendConstants -} - -class VkStencilOpState { - VkStencilOp failOp - VkStencilOp passOp - VkStencilOp depthFailOp - VkCompareOp compareOp - u32 compareMask - u32 writeMask - u32 reference -} - -class VkPipelineDepthStencilStateCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineDepthStencilStateCreateFlags flags - VkBool32 depthTestEnable - VkBool32 depthWriteEnable - VkCompareOp depthCompareOp - VkBool32 depthBoundsTestEnable /// optional (depth_bounds_test) - VkBool32 stencilTestEnable - VkStencilOpState front - VkStencilOpState back - f32 minDepthBounds - f32 maxDepthBounds -} - -class VkPipelineDynamicStateCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineDynamicStateCreateFlags flags - u32 dynamicStateCount - const VkDynamicState* pDynamicStates -} - -class VkGraphicsPipelineCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineCreateFlags flags /// Pipeline creation flags - u32 stageCount - const VkPipelineShaderStageCreateInfo* pStages /// One entry for each active shader stage - const VkPipelineVertexInputStateCreateInfo* pVertexInputState - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState - const VkPipelineTessellationStateCreateInfo* pTessellationState - const VkPipelineViewportStateCreateInfo* pViewportState - const VkPipelineRasterizationStateCreateInfo* pRasterizationState - const VkPipelineMultisampleStateCreateInfo* pMultisampleState - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState - const VkPipelineColorBlendStateCreateInfo* pColorBlendState - const VkPipelineDynamicStateCreateInfo* pDynamicState - VkPipelineLayout layout /// Interface layout of the pipeline - VkRenderPass renderPass - u32 subpass - VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of - s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of -} - -class VkPipelineCacheCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineCacheCreateFlags flags - platform.size_t initialDataSize /// Size of initial data to populate cache, in bytes - const void* pInitialData /// Initial data to populate cache -} - -class VkPushConstantRange { - VkShaderStageFlags stageFlags /// Which stages use the range - u32 offset /// Start of the range, in bytes - u32 size /// Length of the range, in bytes -} - -class VkPipelineLayoutCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO - const void* pNext /// Pointer to next structure - VkPipelineLayoutCreateFlags flags - u32 descriptorSetCount /// Number of descriptor sets interfaced by the pipeline - const VkDescriptorSetLayout* pSetLayouts /// Array of <setCount> number of descriptor set layout objects defining the layout of the - u32 pushConstantRangeCount /// Number of push-constant ranges used by the pipeline - const VkPushConstantRange* pPushConstantRanges /// Array of pushConstantRangeCount number of ranges used by various shader stages -} - -class VkSamplerCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO - const void* pNext /// Pointer to next structure - VkSamplerCreateFlags flags - VkFilter magFilter /// Filter mode for magnification - VkFilter minFilter /// Filter mode for minifiation - VkSamplerMipmapMode mipmapMode /// Mipmap selection mode - VkSamplerAddressMode addressModeU - VkSamplerAddressMode addressModeV - VkSamplerAddressMode addressModeW - f32 mipLodBias - VkBool32 anisotropyEnable - f32 maxAnisotropy - VkBool32 compareEnable - VkCompareOp compareOp - f32 minLod - f32 maxLod - VkBorderColor borderColor - VkBool32 unnormalizedCoordinates -} - -class VkCommandPoolCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO - const void* pNext /// Pointer to next structure - VkCommandPoolCreateFlags flags /// Command pool creation flags - u32 queueFamilyIndex -} - -class VkCommandBufferAllocateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO - const void* pNext /// Pointer to next structure - VkCommandPool commandPool - VkCommandBufferLevel level - u32 commandBufferCount -} - -class VkCommandBufferInheritanceInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO - const void* pNext /// Pointer to next structure - VkRenderPass renderPass /// Render pass for secondary command buffers - u32 subpass - VkFramebuffer framebuffer /// Framebuffer for secondary command buffers - VkBool32 occlusionQueryEnable - VkQueryControlFlags queryFlags - VkQueryPipelineStatisticFlags pipelineStatistics -} - -class VkCommandBufferBeginInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO - const void* pNext /// Pointer to next structure - VkCommandBufferUsageFlags flags /// Command buffer usage flags - const VkCommandBufferInheritanceInfo* pInheritanceInfo -} - -class VkRenderPassBeginInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO - const void* pNext /// Pointer to next structure - VkRenderPass renderPass - VkFramebuffer framebuffer - VkRect2D renderArea - u32 clearValueCount - const VkClearValue* pClearValues -} - -@union -/// Union allowing specification of floating point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared. -class VkClearColorValue { - f32[4] float32 - s32[4] int32 - u32[4] uint32 -} - -class VkClearDepthStencilValue { - f32 depth - u32 stencil -} - -@union -/// Union allowing specification of color, depth, and stencil color values. Actual value selected is based on attachment being cleared. -class VkClearValue { - VkClearColorValue color - VkClearDepthStencilValue depthStencil -} - -class VkClearAttachment { - VkImageAspectFlags aspectMask - u32 colorAttachment - VkClearValue clearValue -} - -class VkAttachmentDescription { - VkAttachmentDescriptionFlags flags - VkFormat format - VkSampleCountFlagBits samples - VkAttachmentLoadOp loadOp /// Load op for color or depth data - VkAttachmentStoreOp storeOp /// Store op for color or depth data - VkAttachmentLoadOp stencilLoadOp /// Load op for stencil data - VkAttachmentStoreOp stencilStoreOp /// Store op for stencil data - VkImageLayout initialLayout - VkImageLayout finalLayout -} - -class VkAttachmentReference { - u32 attachment - VkImageLayout layout -} - -class VkSubpassDescription { - VkSubpassDescriptionFlags flags - VkPipelineBindPoint pipelineBindPoint /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now - u32 inputAttachmentCount - const VkAttachmentReference* pInputAttachments - u32 colorAttachmentCount - const VkAttachmentReference* pColorAttachments - const VkAttachmentReference* pResolveAttachments - const VkAttachmentReference* pDepthStencilAttachment - u32 preserveAttachmentCount - const u32* pPreserveAttachments -} - -class VkSubpassDependency { - u32 srcSubpass - u32 dstSubpass - VkPipelineStageFlags srcStageMask - VkPipelineStageFlags dstStageMask - VkAccessFlags srcAccessMask - VkAccessFlags dstAccessMask - VkDependencyFlags dependencyFlags -} - -class VkRenderPassCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO - const void* pNext /// Pointer to next structure - VkRenderPassCreateFlags flags - u32 attachmentCount - const VkAttachmentDescription* pAttachments - u32 subpassCount - const VkSubpassDescription* pSubpasses - u32 dependencyCount - const VkSubpassDependency* pDependencies -} - -class VkEventCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO - const void* pNext /// Pointer to next structure - VkEventCreateFlags flags /// Event creation flags -} - -class VkFenceCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkFenceCreateFlags flags /// Fence creation flags -} - -class VkPhysicalDeviceFeatures { - VkBool32 robustBufferAccess /// out of bounds buffer accesses are well defined - VkBool32 fullDrawIndexUint32 /// full 32-bit range of indices for indexed draw calls - VkBool32 imageCubeArray /// image views which are arrays of cube maps - VkBool32 independentBlend /// blending operations are controlled per-attachment - VkBool32 geometryShader /// geometry stage - VkBool32 tessellationShader /// tessellation control and evaluation stage - VkBool32 sampleRateShading /// per-sample shading and interpolation - VkBool32 dualSrcBlend /// blend operations which take two sources - VkBool32 logicOp /// logic operations - VkBool32 multiDrawIndirect /// multi draw indirect - VkBool32 drawIndirectFirstInstance - VkBool32 depthClamp /// depth clamping - VkBool32 depthBiasClamp /// depth bias clamping - VkBool32 fillModeNonSolid /// point and wireframe fill modes - VkBool32 depthBounds /// depth bounds test - VkBool32 wideLines /// lines with width greater than 1 - VkBool32 largePoints /// points with size greater than 1 - VkBool32 alphaToOne /// The fragment alpha channel can be forced to maximum representable alpha value - VkBool32 multiViewport - VkBool32 samplerAnisotropy - VkBool32 textureCompressionETC2 /// ETC texture compression formats - VkBool32 textureCompressionASTC_LDR /// ASTC LDR texture compression formats - VkBool32 textureCompressionBC /// BC1-7 texture compressed formats - VkBool32 occlusionQueryPrecise - VkBool32 pipelineStatisticsQuery /// pipeline statistics query - VkBool32 vertexPipelineStoresAndAtomics - VkBool32 fragmentStoresAndAtomics - VkBool32 shaderTessellationAndGeometryPointSize - VkBool32 shaderImageGatherExtended /// texture gather with run-time values and independent offsets - VkBool32 shaderStorageImageExtendedFormats /// the extended set of formats can be used for storage images - VkBool32 shaderStorageImageMultisample /// multisample images can be used for storage images - VkBool32 shaderStorageImageReadWithoutFormat - VkBool32 shaderStorageImageWriteWithoutFormat - VkBool32 shaderUniformBufferArrayDynamicIndexing /// arrays of uniform buffers can be accessed with dynamically uniform indices - VkBool32 shaderSampledImageArrayDynamicIndexing /// arrays of sampled images can be accessed with dynamically uniform indices - VkBool32 shaderStorageBufferArrayDynamicIndexing /// arrays of storage buffers can be accessed with dynamically uniform indices - VkBool32 shaderStorageImageArrayDynamicIndexing /// arrays of storage images can be accessed with dynamically uniform indices - VkBool32 shaderClipDistance /// clip distance in shaders - VkBool32 shaderCullDistance /// cull distance in shaders - VkBool32 shaderFloat64 /// 64-bit floats (doubles) in shaders - VkBool32 shaderInt64 /// 64-bit integers in shaders - VkBool32 shaderInt16 /// 16-bit integers in shaders - VkBool32 shaderResourceResidency /// shader can use texture operations that return resource residency information (requires sparseNonResident support) - VkBool32 shaderResourceMinLod /// shader can use texture operations that specify minimum resource LOD - VkBool32 sparseBinding /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level - VkBool32 sparseResidencyBuffer /// Sparse resources support: GPU can access partially resident buffers - VkBool32 sparseResidencyImage2D /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-DepthStencil) images - VkBool32 sparseResidencyImage3D /// Sparse resources support: GPU can access partially resident 3D images - VkBool32 sparseResidency2Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples - VkBool32 sparseResidency4Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples - VkBool32 sparseResidency8Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples - VkBool32 sparseResidency16Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples - VkBool32 sparseResidencyAliased /// Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) - VkBool32 variableMultisampleRate - VkBool32 inheritedQueries -} - -class VkPhysicalDeviceLimits { - /// resource maximum sizes - u32 maxImageDimension1D /// max 1D image dimension - u32 maxImageDimension2D /// max 2D image dimension - u32 maxImageDimension3D /// max 3D image dimension - u32 maxImageDimensionCube /// max cubemap image dimension - u32 maxImageArrayLayers /// max layers for image arrays - u32 maxTexelBufferElements - u32 maxUniformBufferRange /// max uniform buffer size (bytes) - u32 maxStorageBufferRange /// max storage buffer size (bytes) - u32 maxPushConstantsSize /// max size of the push constants pool (bytes) - /// memory limits - u32 maxMemoryAllocationCount /// max number of device memory allocations supported - u32 maxSamplerAllocationCount - VkDeviceSize bufferImageGranularity /// Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage - VkDeviceSize sparseAddressSpaceSize /// Total address space available for sparse allocations (bytes) - /// descriptor set limits - u32 maxBoundDescriptorSets /// max number of descriptors sets that can be bound to a pipeline - u32 maxPerStageDescriptorSamplers /// max num of samplers allowed per-stage in a descriptor set - u32 maxPerStageDescriptorUniformBuffers /// max num of uniform buffers allowed per-stage in a descriptor set - u32 maxPerStageDescriptorStorageBuffers /// max num of storage buffers allowed per-stage in a descriptor set - u32 maxPerStageDescriptorSampledImages /// max num of sampled images allowed per-stage in a descriptor set - u32 maxPerStageDescriptorStorageImages /// max num of storage images allowed per-stage in a descriptor set - u32 maxPerStageDescriptorInputAttachments - u32 maxPerStageResources - u32 maxDescriptorSetSamplers /// max num of samplers allowed in all stages in a descriptor set - u32 maxDescriptorSetUniformBuffers /// max num of uniform buffers allowed in all stages in a descriptor set - u32 maxDescriptorSetUniformBuffersDynamic /// max num of dynamic uniform buffers allowed in all stages in a descriptor set - u32 maxDescriptorSetStorageBuffers /// max num of storage buffers allowed in all stages in a descriptor set - u32 maxDescriptorSetStorageBuffersDynamic /// max num of dynamic storage buffers allowed in all stages in a descriptor set - u32 maxDescriptorSetSampledImages /// max num of sampled images allowed in all stages in a descriptor set - u32 maxDescriptorSetStorageImages /// max num of storage images allowed in all stages in a descriptor set - u32 maxDescriptorSetInputAttachments - /// vertex stage limits - u32 maxVertexInputAttributes /// max num of vertex input attribute slots - u32 maxVertexInputBindings /// max num of vertex input binding slots - u32 maxVertexInputAttributeOffset /// max vertex input attribute offset added to vertex buffer offset - u32 maxVertexInputBindingStride /// max vertex input binding stride - u32 maxVertexOutputComponents /// max num of output components written by vertex shader - /// tessellation control stage limits - u32 maxTessellationGenerationLevel /// max level supported by tess primitive generator - u32 maxTessellationPatchSize /// max patch size (vertices) - u32 maxTessellationControlPerVertexInputComponents /// max num of input components per-vertex in TCS - u32 maxTessellationControlPerVertexOutputComponents /// max num of output components per-vertex in TCS - u32 maxTessellationControlPerPatchOutputComponents /// max num of output components per-patch in TCS - u32 maxTessellationControlTotalOutputComponents /// max total num of per-vertex and per-patch output components in TCS - u32 maxTessellationEvaluationInputComponents /// max num of input components per vertex in TES - u32 maxTessellationEvaluationOutputComponents /// max num of output components per vertex in TES - /// geometry stage limits - u32 maxGeometryShaderInvocations /// max invocation count supported in geometry shader - u32 maxGeometryInputComponents /// max num of input components read in geometry stage - u32 maxGeometryOutputComponents /// max num of output components written in geometry stage - u32 maxGeometryOutputVertices /// max num of vertices that can be emitted in geometry stage - u32 maxGeometryTotalOutputComponents /// max total num of components (all vertices) written in geometry stage - /// fragment stage limits - u32 maxFragmentInputComponents /// max num of input compontents read in fragment stage - u32 maxFragmentOutputAttachments /// max num of output attachments written in fragment stage - u32 maxFragmentDualSrcAttachments /// max num of output attachments written when using dual source blending - u32 maxFragmentCombinedOutputResources /// max total num of storage buffers, storage images and output buffers - /// compute stage limits - u32 maxComputeSharedMemorySize /// max total storage size of work group local storage (bytes) - u32[3] maxComputeWorkGroupCount /// max num of compute work groups that may be dispatched by a single command (x,y,z) - u32 maxComputeWorkGroupInvocations /// max total compute invocations in a single local work group - u32[3] maxComputeWorkGroupSize /// max local size of a compute work group (x,y,z) - - u32 subPixelPrecisionBits /// num bits of subpixel precision in screen x and y - u32 subTexelPrecisionBits /// num bits of subtexel precision - u32 mipmapPrecisionBits /// num bits of mipmap precision - - u32 maxDrawIndexedIndexValue /// max index value for indexed draw calls (for 32-bit indices) - u32 maxDrawIndirectCount - - f32 maxSamplerLodBias /// max absolute sampler level of detail bias - f32 maxSamplerAnisotropy /// max degree of sampler anisotropy - - u32 maxViewports /// max number of active viewports - u32[2] maxViewportDimensions /// max viewport dimensions (x,y) - f32[2] viewportBoundsRange /// viewport bounds range (min,max) - u32 viewportSubPixelBits /// num bits of subpixel precision for viewport - - platform.size_t minMemoryMapAlignment /// min required alignment of pointers returned by MapMemory (bytes) - VkDeviceSize minTexelBufferOffsetAlignment /// min required alignment for texel buffer offsets (bytes) - VkDeviceSize minUniformBufferOffsetAlignment /// min required alignment for uniform buffer sizes and offsets (bytes) - VkDeviceSize minStorageBufferOffsetAlignment /// min required alignment for storage buffer offsets (bytes) - - s32 minTexelOffset /// min texel offset for OpTextureSampleOffset - u32 maxTexelOffset /// max texel offset for OpTextureSampleOffset - s32 minTexelGatherOffset /// min texel offset for OpTextureGatherOffset - u32 maxTexelGatherOffset /// max texel offset for OpTextureGatherOffset - f32 minInterpolationOffset /// furthest negative offset for interpolateAtOffset - f32 maxInterpolationOffset /// furthest positive offset for interpolateAtOffset - u32 subPixelInterpolationOffsetBits /// num of subpixel bits for interpolateAtOffset - - u32 maxFramebufferWidth /// max width for a framebuffer - u32 maxFramebufferHeight /// max height for a framebuffer - u32 maxFramebufferLayers /// max layer count for a layered framebuffer - VkSampleCountFlags framebufferColorSampleCounts - VkSampleCountFlags framebufferDepthSampleCounts - VkSampleCountFlags framebufferStencilSampleCounts - VkSampleCountFlags framebufferNoAttachmentSampleCounts - u32 maxColorAttachments /// max num of framebuffer color attachments - - VkSampleCountFlags sampledImageColorSampleCounts - VkSampleCountFlags sampledImageIntegerSampleCounts - VkSampleCountFlags sampledImageDepthSampleCounts - VkSampleCountFlags sampledImageStencilSampleCounts - VkSampleCountFlags storageImageSampleCounts - u32 maxSampleMaskWords /// max num of sample mask words - VkBool32 timestampComputeAndGraphics - - f32 timestampPeriod - - u32 maxClipDistances /// max number of clip distances - u32 maxCullDistances /// max number of cull distances - u32 maxCombinedClipAndCullDistances /// max combined number of user clipping - - u32 discreteQueuePriorities - - f32[2] pointSizeRange /// range (min,max) of supported point sizes - f32[2] lineWidthRange /// range (min,max) of supported line widths - f32 pointSizeGranularity /// granularity of supported point sizes - f32 lineWidthGranularity /// granularity of supported line widths - VkBool32 strictLines - VkBool32 standardSampleLocations - - VkDeviceSize optimalBufferCopyOffsetAlignment - VkDeviceSize optimalBufferCopyRowPitchAlignment - VkDeviceSize nonCoherentAtomSize -} - -class VkPhysicalDeviceSparseProperties { - VkBool32 residencyStandard2DBlockShape /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard block shapes (based on pixel format) - VkBool32 residencyStandard2DMultisampleBlockShape /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format) - VkBool32 residencyStandard3DBlockShape /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format) - VkBool32 residencyAlignedMipSize /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail - VkBool32 residencyNonResidentStrict /// Sparse resources support: GPU can safely access non-resident regions of a resource, all reads return as if data is 0, writes are discarded -} - -class VkSemaphoreCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO - const void* pNext /// Pointer to next structure - VkSemaphoreCreateFlags flags /// Semaphore creation flags -} - -class VkQueryPoolCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO - const void* pNext /// Pointer to next structure - VkQueryPoolCreateFlags flags - VkQueryType queryType - u32 queryCount - VkQueryPipelineStatisticFlags pipelineStatistics /// Optional -} - -class VkFramebufferCreateInfo { - VkStructureType sType /// Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO - const void* pNext /// Pointer to next structure - VkFramebufferCreateFlags flags - VkRenderPass renderPass - u32 attachmentCount - const VkImageView* pAttachments - u32 width - u32 height - u32 layers -} - -class VkDrawIndirectCommand { - u32 vertexCount - u32 instanceCount - u32 firstVertex - u32 firstInstance -} - -class VkDrawIndexedIndirectCommand { - u32 indexCount - u32 instanceCount - u32 firstIndex - s32 vertexOffset - u32 firstInstance -} - -class VkDispatchIndirectCommand { - u32 x - u32 y - u32 z -} - -class VkBaseOutStructure { - VkStructureType sType - void* pNext -} - -class VkBaseInStructure { - VkStructureType sType - const void* pNext -} - -//@vulkan1_1 structures - -class VkPhysicalDeviceSubgroupProperties { - VkStructureType sType - void* pNext - u32 subgroupSize - VkShaderStageFlags supportedStages - VkSubgroupFeatureFlags supportedOperations - VkBool32 quadOperationsInAllStages -} - -class VkBindBufferMemoryInfo { - VkStructureType sType - const void* pNext - VkBuffer buffer - VkDeviceMemory memory - VkDeviceSize memoryOffset -} - -class VkBindImageMemoryInfo { - VkStructureType sType - const void* pNext - VkImage image - VkDeviceMemory memory - VkDeviceSize memoryOffset -} - -class VkPhysicalDevice16BitStorageFeatures { - VkStructureType sType - void* pNext - VkBool32 storageBuffer16BitAccess - VkBool32 uniformAndStorageBuffer16BitAccess - VkBool32 storagePushConstant16 - VkBool32 storageInputOutput16 -} - -class VkMemoryDedicatedRequirements { - VkStructureType sType - void* pNext - VkBool32 prefersDedicatedAllocation - VkBool32 requiresDedicatedAllocation -} - -class VkMemoryDedicatedAllocateInfo { - VkStructureType sType - const void* pNext - VkImage image - VkBuffer buffer -} - -class VkMemoryAllocateFlagsInfo { - VkStructureType sType - const void* pNext - VkMemoryAllocateFlags flags - u32 deviceMask -} - -class VkDeviceGroupRenderPassBeginInfo { - VkStructureType sType - const void* pNext - u32 deviceMask - u32 deviceRenderAreaCount - const VkRect2D* pDeviceRenderAreas -} - -class VkDeviceGroupCommandBufferBeginInfo { - VkStructureType sType - const void* pNext - u32 deviceMask -} - -class VkDeviceGroupSubmitInfo { - VkStructureType sType - const void* pNext - u32 waitSemaphoreCount - const u32* pWaitSemaphoreDeviceIndices - u32 commandBufferCount - const u32* pCommandBufferDeviceMasks - u32 signalSemaphoreCount - const u32* pSignalSemaphoreDeviceIndices -} - -class VkDeviceGroupBindSparseInfo { - VkStructureType sType - const void* pNext - u32 resourceDeviceIndex - u32 memoryDeviceIndex -} - -class VkBindBufferMemoryDeviceGroupInfo { - VkStructureType sType - const void* pNext - u32 deviceIndexCount - const u32* pDeviceIndices -} - -class VkBindImageMemoryDeviceGroupInfo { - VkStructureType sType - const void* pNext - u32 deviceIndexCount - const u32* pDeviceIndices - u32 splitInstanceBindRegionCount - const VkRect2D* pSplitInstanceBindRegions -} - -class VkPhysicalDeviceGroupProperties { - VkStructureType sType - void* pNext - u32 physicalDeviceCount - VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE] physicalDevices - VkBool32 subsetAllocation -} - -class VkDeviceGroupDeviceCreateInfo { - VkStructureType sType - const void* pNext - u32 physicalDeviceCount - const VkPhysicalDevice* pPhysicalDevices -} - -class VkBufferMemoryRequirementsInfo2 { - VkStructureType sType - const void* pNext - VkBuffer buffer -} - -class VkImageMemoryRequirementsInfo2 { - VkStructureType sType - const void* pNext - VkImage image -} - -class VkImageSparseMemoryRequirementsInfo2 { - VkStructureType sType - const void* pNext - VkImage image -} - -class VkMemoryRequirements2 { - VkStructureType sType - void* pNext - VkMemoryRequirements memoryRequirements -} - -class VkSparseImageMemoryRequirements2 { - VkStructureType sType - void* pNext - VkSparseImageMemoryRequirements memoryRequirements -} - -class VkPhysicalDeviceFeatures2 { - VkStructureType sType - void* pNext - VkPhysicalDeviceFeatures features -} - -class VkPhysicalDeviceProperties2 { - VkStructureType sType - void* pNext - VkPhysicalDeviceProperties properties -} - -class VkFormatProperties2 { - VkStructureType sType - void* pNext - VkFormatProperties formatProperties -} - -class VkImageFormatProperties2 { - VkStructureType sType - void* pNext - VkImageFormatProperties imageFormatProperties -} - -class VkPhysicalDeviceImageFormatInfo2 { - VkStructureType sType - const void* pNext - VkFormat format - VkImageType type - VkImageTiling tiling - VkImageUsageFlags usage - VkImageCreateFlags flags -} - -class VkQueueFamilyProperties2 { - VkStructureType sType - void* pNext - VkQueueFamilyProperties queueFamilyProperties -} - -class VkPhysicalDeviceMemoryProperties2 { - VkStructureType sType - void* pNext - VkPhysicalDeviceMemoryProperties memoryProperties -} - -class VkSparseImageFormatProperties2 { - VkStructureType sType - void* pNext - VkSparseImageFormatProperties properties -} - -class VkPhysicalDeviceSparseImageFormatInfo2 { - VkStructureType sType - const void* pNext - VkFormat format - VkImageType type - VkSampleCountFlagBits samples - VkImageUsageFlags usage - VkImageTiling tiling -} - -class VkPhysicalDevicePointClippingProperties { - VkStructureType sType - void* pNext - VkPointClippingBehavior pointClippingBehavior -} - -class VkInputAttachmentAspectReference { - u32 subpass - u32 inputAttachmentIndex - VkImageAspectFlags aspectMask -} - -class VkRenderPassInputAttachmentAspectCreateInfo { - VkStructureType sType - const void* pNext - u32 aspectReferenceCount - const VkInputAttachmentAspectReference* pAspectReferences -} - -class VkImageViewUsageCreateInfo { - VkStructureType sType - const void* pNext - VkImageUsageFlags usage -} - -class VkPipelineTessellationDomainOriginStateCreateInfo { - VkStructureType sType - const void* pNext - VkTessellationDomainOrigin domainOrigin -} - -class VkRenderPassMultiviewCreateInfo { - VkStructureType sType - const void* pNext - u32 subpassCount - const u32* pViewMasks - u32 dependencyCount - const s32* pViewOffsets - u32 correlationMaskCount - const u32* pCorrelationMasks -} - -class VkPhysicalDeviceMultiviewFeatures { - VkStructureType sType - void* pNext - VkBool32 multiview - VkBool32 multiviewGeometryShader - VkBool32 multiviewTessellationShader -} - -class VkPhysicalDeviceMultiviewProperties { - VkStructureType sType - void* pNext - u32 maxMultiviewViewCount - u32 maxMultiviewInstanceIndex -} - -class VkPhysicalDeviceVariablePointerFeatures { - VkStructureType sType - void* pNext - VkBool32 variablePointersStorageBuffer - VkBool32 variablePointers -} - -class VkPhysicalDeviceProtectedMemoryFeatures { - VkStructureType sType - void* pNext - VkBool32 protectedMemory -} - -class VkPhysicalDeviceProtectedMemoryProperties { - VkStructureType sType - void* pNext - VkBool32 protectedNoFault -} - -class VkDeviceQueueInfo2 { - VkStructureType sType - const void* pNext - VkDeviceQueueCreateFlags flags - u32 queueFamilyIndex - u32 queueIndex -} - -class VkProtectedSubmitInfo { - VkStructureType sType - const void* pNext - VkBool32 protectedSubmit -} - -class VkSamplerYcbcrConversionCreateInfo { - VkStructureType sType - const void* pNext - VkFormat format - VkSamplerYcbcrModelConversion ycbcrModel - VkSamplerYcbcrRange ycbcrRange - VkComponentMapping components - VkChromaLocation xChromaOffset - VkChromaLocation yChromaOffset - VkFilter chromaFilter - VkBool32 forceExplicitReconstruction -} - -class VkSamplerYcbcrConversionInfo { - VkStructureType sType - const void* pNext - VkSamplerYcbcrConversion conversion -} - -class VkBindImagePlaneMemoryInfo { - VkStructureType sType - const void* pNext - VkImageAspectFlagBits planeAspect -} - -class VkImagePlaneMemoryRequirementsInfo { - VkStructureType sType - const void* pNext - VkImageAspectFlagBits planeAspect -} - -class VkPhysicalDeviceSamplerYcbcrConversionFeatures { - VkStructureType sType - void* pNext - VkBool32 samplerYcbcrConversion -} - -class VkSamplerYcbcrConversionImageFormatProperties { - VkStructureType sType - void* pNext - u32 combinedImageSamplerDescriptorCount -} - -class VkDescriptorUpdateTemplateEntry { - u32 dstBinding - u32 dstArrayElement - u32 descriptorCount - VkDescriptorType descriptorType - platform.size_t offset - platform.size_t stride -} - -class VkDescriptorUpdateTemplateCreateInfo { - VkStructureType sType - const void* pNext - VkDescriptorUpdateTemplateCreateFlags flags - u32 descriptorUpdateEntryCount - const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries - VkDescriptorUpdateTemplateType templateType - VkDescriptorSetLayout descriptorSetLayout - VkPipelineBindPoint pipelineBindPoint - VkPipelineLayout pipelineLayout - u32 set -} - -class VkExternalMemoryProperties { - VkExternalMemoryFeatureFlags externalMemoryFeatures - VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlags compatibleHandleTypes -} - -class VkPhysicalDeviceExternalImageFormatInfo { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType -} - -class VkExternalImageFormatProperties { - VkStructureType sType - void* pNext - VkExternalMemoryProperties externalMemoryProperties -} - -class VkPhysicalDeviceExternalBufferInfo { - VkStructureType sType - const void* pNext - VkBufferCreateFlags flags - VkBufferUsageFlags usage - VkExternalMemoryHandleTypeFlagBits handleType -} - -class VkExternalBufferProperties { - VkStructureType sType - void* pNext - VkExternalMemoryProperties externalMemoryProperties -} - -class VkPhysicalDeviceIDProperties { - VkStructureType sType - void* pNext - u8[VK_UUID_SIZE] deviceUUID - u8[VK_UUID_SIZE] driverUUID - u8[VK_LUID_SIZE] deviceLUID - u32 deviceNodeMask - VkBool32 deviceLUIDValid -} - -class VkExternalMemoryImageCreateInfo { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes -} - -class VkExternalMemoryBufferCreateInfo { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes -} - -class VkExportMemoryAllocateInfo { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlags handleTypes -} - -class VkPhysicalDeviceExternalFenceInfo { - VkStructureType sType - const void* pNext - VkExternalFenceHandleTypeFlagBits handleType -} - -class VkExternalFenceProperties { - VkStructureType sType - void* pNext - VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes - VkExternalFenceHandleTypeFlags compatibleHandleTypes - VkExternalFenceFeatureFlags externalFenceFeatures -} - -class VkExportFenceCreateInfo { - VkStructureType sType - const void* pNext - VkExternalFenceHandleTypeFlags handleTypes -} - -class VkExportSemaphoreCreateInfo { - VkStructureType sType - const void* pNext - VkExternalSemaphoreHandleTypeFlags handleTypes -} - -class VkPhysicalDeviceExternalSemaphoreInfo { - VkStructureType sType - const void* pNext - VkExternalSemaphoreHandleTypeFlagBits handleType -} - -class VkExternalSemaphoreProperties { - VkStructureType sType - void* pNext - VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes - VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes - VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures -} - -class VkPhysicalDeviceMaintenance3Properties { - VkStructureType sType - void* pNext - u32 maxPerSetDescriptors - VkDeviceSize maxMemoryAllocationSize -} - -class VkDescriptorSetLayoutSupport { - VkStructureType sType - void* pNext - VkBool32 supported -} - -class VkPhysicalDeviceShaderDrawParameterFeatures { - VkStructureType sType - void* pNext - VkBool32 shaderDrawParameters -} - - -@extension("VK_KHR_surface") // 1 -class VkSurfaceCapabilitiesKHR { - u32 minImageCount - u32 maxImageCount - VkExtent2D currentExtent - VkExtent2D minImageExtent - VkExtent2D maxImageExtent - u32 maxImageArrayLayers - VkSurfaceTransformFlagsKHR supportedTransforms - VkSurfaceTransformFlagBitsKHR currentTransform - VkCompositeAlphaFlagsKHR supportedCompositeAlpha - VkImageUsageFlags supportedUsageFlags -} - -@extension("VK_KHR_surface") // 1 -class VkSurfaceFormatKHR { - VkFormat format - VkColorSpaceKHR colorSpace -} - -@extension("VK_KHR_swapchain") // 2 -class VkSwapchainCreateInfoKHR { - VkStructureType sType - const void* pNext - VkSwapchainCreateFlagsKHR flags - VkSurfaceKHR surface - u32 minImageCount - VkFormat imageFormat - VkColorSpaceKHR imageColorSpace - VkExtent2D imageExtent - u32 imageArrayLayers - VkImageUsageFlags imageUsage - VkSharingMode sharingMode - u32 queueFamilyIndexCount - const u32* pQueueFamilyIndices - VkSurfaceTransformFlagBitsKHR preTransform - VkCompositeAlphaFlagBitsKHR compositeAlpha - VkPresentModeKHR presentMode - VkBool32 clipped - VkSwapchainKHR oldSwapchain -} - -@extension("VK_KHR_swapchain") // 2 -class VkPresentInfoKHR { - VkStructureType sType - const void* pNext - u32 waitSemaphoreCount - const VkSemaphore* pWaitSemaphores - u32 swapchainCount - const VkSwapchainKHR* pSwapchains - const u32* pImageIndices - VkResult* pResults -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -class VkImageSwapchainCreateInfoKHR { - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -class VkBindImageMemorySwapchainInfoKHR { - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain - u32 imageIndex -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -class VkAcquireNextImageInfoKHR { - VkStructureType sType - const void* pNext - VkSwapchainKHR swapchain - u64 timeout - VkSemaphore semaphore - VkFence fence - u32 deviceMask -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -class VkDeviceGroupPresentCapabilitiesKHR { - VkStructureType sType - const void* pNext - u32[VK_MAX_DEVICE_GROUP_SIZE] presentMask - VkDeviceGroupPresentModeFlagsKHR modes -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -class VkDeviceGroupPresentInfoKHR { - VkStructureType sType - const void* pNext - u32 swapchainCount - const u32* pDeviceMasks - VkDeviceGroupPresentModeFlagBitsKHR mode -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -class VkDeviceGroupSwapchainCreateInfoKHR { - VkStructureType sType - const void* pNext - VkDeviceGroupPresentModeFlagsKHR modes -} - -@extension("VK_KHR_display") // 3 -class VkDisplayPropertiesKHR { - VkDisplayKHR display - const char* displayName - VkExtent2D physicalDimensions - VkExtent2D physicalResolution - VkSurfaceTransformFlagsKHR supportedTransforms - VkBool32 planeReorderPossible - VkBool32 persistentContent -} - -@extension("VK_KHR_display") // 3 -class VkDisplayModeParametersKHR { - VkExtent2D visibleRegion - u32 refreshRate -} - -@extension("VK_KHR_display") // 3 -class VkDisplayModePropertiesKHR { - VkDisplayModeKHR displayMode - VkDisplayModeParametersKHR parameters -} - -@extension("VK_KHR_display") // 3 -class VkDisplayModeCreateInfoKHR { - VkStructureType sType - const void* pNext - VkDisplayModeCreateFlagsKHR flags - VkDisplayModeParametersKHR parameters -} - -@extension("VK_KHR_display") // 3 -class VkDisplayPlanePropertiesKHR { - VkDisplayKHR currentDisplay - u32 currentStackIndex -} - -@extension("VK_KHR_display") // 3 -class VkDisplayPlaneCapabilitiesKHR { - VkDisplayPlaneAlphaFlagsKHR supportedAlpha - VkOffset2D minSrcPosition - VkOffset2D maxSrcPosition - VkExtent2D minSrcExtent - VkExtent2D maxSrcExtent - VkOffset2D minDstPosition - VkOffset2D maxDstPosition - VkExtent2D minDstExtent - VkExtent2D maxDstExtent -} - -@extension("VK_KHR_display") // 3 -class VkDisplaySurfaceCreateInfoKHR { - VkStructureType sType - const void* pNext - VkDisplaySurfaceCreateFlagsKHR flags - VkDisplayModeKHR displayMode - u32 planeIndex - u32 planeStackIndex - VkSurfaceTransformFlagBitsKHR transform - f32 globalAlpha - VkDisplayPlaneAlphaFlagBitsKHR alphaMode - VkExtent2D imageExtent -} - -@extension("VK_KHR_display_swapchain") // 4 -class VkDisplayPresentInfoKHR { - VkStructureType sType - const void* pNext - VkRect2D srcRect - VkRect2D dstRect - VkBool32 persistent -} - -@extension("VK_KHR_xlib_surface") // 5 -class VkXlibSurfaceCreateInfoKHR { - VkStructureType sType - const void* pNext - VkXlibSurfaceCreateFlagsKHR flags - platform.Display* dpy - platform.Window window -} - -@extension("VK_KHR_xcb_surface") // 6 -class VkXcbSurfaceCreateInfoKHR { - VkStructureType sType - const void* pNext - VkXcbSurfaceCreateFlagsKHR flags - platform.xcb_connection_t* connection - platform.xcb_window_t window -} - -@extension("VK_KHR_wayland_surface") // 7 -class VkWaylandSurfaceCreateInfoKHR { - VkStructureType sType - const void* pNext - VkWaylandSurfaceCreateFlagsKHR flags - platform.wl_display* display - platform.wl_surface* surface -} - -@extension("VK_KHR_android_surface") // 9 -class VkAndroidSurfaceCreateInfoKHR { - VkStructureType sType - const void* pNext - VkAndroidSurfaceCreateFlagsKHR flags - platform.ANativeWindow* window -} - -@extension("VK_KHR_win32_surface") // 10 -class VkWin32SurfaceCreateInfoKHR { - VkStructureType sType - const void* pNext - VkWin32SurfaceCreateFlagsKHR flags - platform.HINSTANCE hinstance - platform.HWND hwnd -} - -@extension("VK_ANDROID_native_buffer") // 11 -@internal class Gralloc1Usage { - u64 consumer - u64 producer -} - -@extension("VK_ANDROID_native_buffer") // 11 -class VkNativeBufferANDROID { - VkStructureType sType - const void* pNext - platform.buffer_handle_t handle - s32 stride - s32 format - s32 usage - Gralloc1Usage usage2 -} - -@extension("VK_ANDROID_native_buffer") // 11 -class VkSwapchainImageCreateInfoANDROID { - VkStructureType sType - const void* pNext - VkSwapchainImageUsageFlagsANDROID flags -} - -@extension("VK_ANDROID_native_buffer") // 11 -class VkPhysicalDevicePresentationPropertiesANDROID { - VkStructureType sType - void* pNext - VkBool32 sharedImage -} - -@extension("VK_EXT_debug_report") // 12 -class VkDebugReportCallbackCreateInfoEXT { - VkStructureType sType - const void* pNext - VkDebugReportFlagsEXT flags - PFN_vkDebugReportCallbackEXT pfnCallback - void* pUserData -} - -@extension("VK_AMD_rasterization_order") // 19 -class VkPipelineRasterizationStateRasterizationOrderAMD { - VkStructureType sType - const void* pNext - VkRasterizationOrderAMD rasterizationOrder -} - -@extension("VK_EXT_debug_marker") // 23 -class VkDebugMarkerObjectNameInfoEXT { - VkStructureType sType - const void* pNext - VkDebugReportObjectTypeEXT objectType - u64 object - const char* pObjectName -} - -@extension("VK_EXT_debug_marker") // 23 -class VkDebugMarkerObjectTagInfoEXT { - VkStructureType sType - const void* pNext - VkDebugReportObjectTypeEXT objectType - u64 object - u64 tagName - platform.size_t tagSize - const void* pTag -} - -@extension("VK_EXT_debug_marker") // 23 -class VkDebugMarkerMarkerInfoEXT { - VkStructureType sType - const void* pNext - const char* pMarkerName - f32[4] color -} - -@extension("VK_NV_dedicated_allocation") // 27 -class VkDedicatedAllocationImageCreateInfoNV { - VkStructureType sType - const void* pNext - VkBool32 dedicatedAllocation -} - -@extension("VK_NV_dedicated_allocation") // 27 -class VkDedicatedAllocationBufferCreateInfoNV { - VkStructureType sType - const void* pNext - VkBool32 dedicatedAllocation -} - -@extension("VK_NV_dedicated_allocation") // 27 -class VkDedicatedAllocationMemoryAllocateInfoNV { - VkStructureType sType - const void* pNext - VkImage image - VkBuffer buffer -} - -@extension("VK_EXT_transform_feedback") // 29 -class VkPhysicalDeviceTransformFeedbackFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 transformFeedback - VkBool32 geometryStreams -} - -@extension("VK_EXT_transform_feedback") // 29 -class VkPhysicalDeviceTransformFeedbackPropertiesEXT { - VkStructureType sType - void* pNext - u32 maxTransformFeedbackStreams - u32 maxTransformFeedbackBuffers - VkDeviceSize maxTransformFeedbackBufferSize - u32 maxTransformFeedbackStreamDataSize - u32 maxTransformFeedbackBufferDataSize - u32 maxTransformFeedbackBufferDataStride - VkBool32 transformFeedbackQueries - VkBool32 transformFeedbackStreamsLinesTriangles - VkBool32 transformFeedbackRasterizationStreamSelect - VkBool32 transformFeedbackDraw -} - -@extension("VK_EXT_transform_feedback") // 29 -class VkPipelineRasterizationStateStreamCreateInfoEXT { - VkStructureType sType - const void* pNext - VkPipelineRasterizationStateStreamCreateFlagsEXT flags - u32 rasterizationStream -} - -@extension("VK_AMD_texture_gather_bias_lod") // 42 -class VkTextureLODGatherFormatPropertiesAMD { - VkStructureType sType - void* pNext - VkBool32 supportsTextureGatherLODBiasAMD -} - -@extension("VK_AMD_shader_info") // 43 -class VkShaderResourceUsageAMD { - u32 numUsedVgprs - u32 numUsedSgprs - u32 ldsSizePerLocalWorkGroup - platform.size_t ldsUsageSizeInBytes - platform.size_t scratchMemUsageInBytes -} - -@extension("VK_AMD_shader_info") // 43 -class VkShaderStatisticsInfoAMD { - VkShaderStageFlags shaderStageMask - VkShaderResourceUsageAMD resourceUsage - u32 numPhysicalVgprs - u32 numPhysicalSgprs - u32 numAvailableVgprs - u32 numAvailableSgprs - u32[3] computeWorkGroupSize -} - -@extension("VK_NV_corner_sampled_image") // 51 -class VkPhysicalDeviceCornerSampledImageFeaturesNV { - VkStructureType sType - void* pNext - VkBool32 cornerSampledImage -} - -@extension("VK_KHR_multiview") // 54 -class VkRenderPassMultiviewCreateInfoKHR { - VkStructureType sType - const void* pNext - u32 subpassCount - const u32* pViewMasks - u32 dependencyCount - const s32* pViewOffsets - u32 correlationMaskCount - const u32* pCorrelationMasks -} - -@extension("VK_KHR_multiview") // 54 -class VkPhysicalDeviceMultiviewFeaturesKHR { - VkStructureType sType - void* pNext - VkBool32 multiview - VkBool32 multiviewGeometryShader - VkBool32 multiviewTessellationShader -} - -@extension("VK_KHR_multiview") // 54 -class VkPhysicalDeviceMultiviewPropertiesKHR { - VkStructureType sType - void* pNext - u32 maxMultiviewViewCount - u32 maxMultiviewInstanceIndex -} - -@extension("VK_NV_external_memory_capabilities") // 56 -class VkExternalImageFormatPropertiesNV { - VkImageFormatProperties imageFormatProperties - VkExternalMemoryFeatureFlagsNV externalMemoryFeatures - VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes -} - -@extension("VK_NV_external_memory") // 57 -class VkExternalMemoryImageCreateInfoNV { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleTypes -} - -@extension("VK_NV_external_memory") // 57 -class VkExportMemoryAllocateInfoNV { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleTypes -} - -@extension("VK_NV_external_memory_win32") // 58 -class VkImportMemoryWin32HandleInfoNV { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleType - platform.HANDLE handle -} - -@extension("VK_NV_external_memory_win32") // 58 -class VkExportMemoryWin32HandleInfoNV { - VkStructureType sType - const void* pNext - const platform.SECURITY_ATTRIBUTES* pAttributes - platform.DWORD dwAccess -} - -@extension("VK_NV_win32_keyed_mutex") // 59 -class VkWin32KeyedMutexAcquireReleaseInfoNV { - VkStructureType sType - const void* pNext - u32 acquireCount - const VkDeviceMemory* pAcquireSyncs - const u64* pAcquireKeys - const u32* pAcquireTimeoutMilliseconds - u32 releaseCount - const VkDeviceMemory* pReleaseSyncs - const u64* pReleaseKeys -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkPhysicalDeviceFeatures2KHR { - VkStructureType sType - void* pNext - VkPhysicalDeviceFeatures features -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkPhysicalDeviceProperties2KHR { - VkStructureType sType - void* pNext - VkPhysicalDeviceProperties properties -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkFormatProperties2KHR { - VkStructureType sType - void* pNext - VkFormatProperties formatProperties -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkImageFormatProperties2KHR { - VkStructureType sType - void* pNext - VkImageFormatProperties imageFormatProperties -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkPhysicalDeviceImageFormatInfo2KHR { - VkStructureType sType - const void* pNext - VkFormat format - VkImageType type - VkImageTiling tiling - VkImageUsageFlags usage - VkImageCreateFlags flags -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkQueueFamilyProperties2KHR { - VkStructureType sType - void* pNext - VkQueueFamilyProperties queueFamilyProperties -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkPhysicalDeviceMemoryProperties2KHR { - VkStructureType sType - void* pNext - VkPhysicalDeviceMemoryProperties memoryProperties -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkSparseImageFormatProperties2KHR { - VkStructureType sType - void* pNext - VkSparseImageFormatProperties properties -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -class VkPhysicalDeviceSparseImageFormatInfo2KHR { - VkStructureType sType - const void* pNext - VkFormat format - VkImageType type - VkSampleCountFlagBits samples - VkImageUsageFlags usage - VkImageTiling tiling -} - -@extension("VK_KHR_device_group") // 61 -class VkMemoryAllocateFlagsInfoKHR { - VkStructureType sType - const void* pNext - VkMemoryAllocateFlagsKHR flags - u32 deviceMask -} - -@extension("VK_KHR_device_group") // 61 -class VkBindBufferMemoryDeviceGroupInfoKHR { - VkStructureType sType - const void* pNext - u32 deviceIndexCount - const u32* pDeviceIndices -} - -@extension("VK_KHR_device_group") // 61 -class VkBindImageMemoryDeviceGroupInfoKHR { - VkStructureType sType - const void* pNext - u32 deviceIndexCount - const u32* pDeviceIndices - u32 SFRRectCount - const VkRect2D* pSFRRects -} - -@extension("VK_KHR_device_group") // 61 -class VkDeviceGroupRenderPassBeginInfoKHR { - VkStructureType sType - const void* pNext - u32 deviceMask - u32 deviceRenderAreaCount - const VkRect2D* pDeviceRenderAreas -} - -@extension("VK_KHR_device_group") // 61 -class VkDeviceGroupCommandBufferBeginInfoKHR { - VkStructureType sType - const void* pNext - u32 deviceMask -} - -@extension("VK_KHR_device_group") // 61 -class VkDeviceGroupSubmitInfoKHR { - VkStructureType sType - const void* pNext - u32 waitSemaphoreCount - const u32* pWaitSemaphoreDeviceIndices - u32 commandBufferCount - const u32* pCommandBufferDeviceMasks - u32 signalSemaphoreCount - const u32* pSignalSemaphoreDeviceIndices -} - -@extension("VK_KHR_device_group") // 61 -class VkDeviceGroupBindSparseInfoKHR { - VkStructureType sType - const void* pNext - u32 resourceDeviceIndex - u32 memoryDeviceIndex -} - -@extension("VK_EXT_validation_flags") // 62 -class VkValidationFlagsEXT { - VkStructureType sType - const void* pNext - u32 disabledValidationCheckCount - const VkValidationCheckEXT* pDisabledValidationChecks -} - -@extension("VK_NN_vi_surface") // 63 -class VkViSurfaceCreateInfoNN { - VkStructureType sType - const void* pNext - VkViSurfaceCreateFlagsNN flags - void* window -} - -@extension("VK_EXT_astc_decode_mode") // 68 -class VkImageViewASTCDecodeModeEXT { - VkStructureType sType - const void* pNext - VkFormat decodeMode -} - -@extension("VK_EXT_astc_decode_mode") // 68 -class VkPhysicalDeviceASTCDecodeFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 decodeModeSharedExponent -} - -@extension("VK_KHR_device_group_creation") // 71 -class VkPhysicalDeviceGroupPropertiesKHR { - VkStructureType sType - void* pNext - u32 physicalDeviceCount - VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE] physicalDevices - VkBool32 subsetAllocation -} - -@extension("VK_KHR_device_group_creation") // 71 -class VkDeviceGroupDeviceCreateInfoKHR { - VkStructureType sType - const void* pNext - u32 physicalDeviceCount - const VkPhysicalDevice* pPhysicalDevices -} - -@extension("VK_KHR_external_memory_capabilities") // 72 -class VkExternalMemoryPropertiesKHR { - VkExternalMemoryFeatureFlagsKHR externalMemoryFeatures - VkExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes -} - -@extension("VK_KHR_external_memory_capabilities") // 72 -class VkPhysicalDeviceExternalImageFormatInfoKHR { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_external_memory_capabilities") // 72 -class VkExternalImageFormatPropertiesKHR { - VkStructureType sType - void* pNext - VkExternalMemoryPropertiesKHR externalMemoryProperties -} - -@extension("VK_KHR_external_memory_capabilities") // 72 -class VkPhysicalDeviceExternalBufferInfoKHR { - VkStructureType sType - const void* pNext - VkBufferCreateFlags flags - VkBufferUsageFlags usage - VkExternalMemoryHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_external_memory_capabilities") // 72 -class VkExternalBufferPropertiesKHR { - VkStructureType sType - void* pNext - VkExternalMemoryPropertiesKHR externalMemoryProperties -} - -@extension("VK_KHR_external_memory_capabilities") // 72 -class VkPhysicalDeviceIDPropertiesKHR { - VkStructureType sType - void* pNext - u8[VK_UUID_SIZE] deviceUUID - u8[VK_UUID_SIZE] driverUUID - u8[VK_LUID_SIZE] deviceLUID - u32 deviceNodeMask - VkBool32 deviceLUIDValid -} - -@extension("VK_KHR_external_memory") // 73 -class VkExternalMemoryImageCreateInfoKHR { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsKHR handleTypes -} - -@extension("VK_KHR_external_memory") // 73 -class VkExternalMemoryBufferCreateInfoKHR { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsKHR handleTypes -} - -@extension("VK_KHR_external_memory") // 73 -class VkExportMemoryAllocateInfoKHR { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsKHR handleTypes -} - -@extension("VK_KHR_external_memory_win32") // 74 -class VkImportMemoryWin32HandleInfoKHR { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBitsKHR handleType - platform.HANDLE handle - platform.LPCWSTR name -} - -@extension("VK_KHR_external_memory_win32") // 74 -class VkExportMemoryWin32HandleInfoKHR { - VkStructureType sType - const void* pNext - const platform.SECURITY_ATTRIBUTES* pAttributes - platform.DWORD dwAccess - platform.LPCWSTR name -} - -@extension("VK_KHR_external_memory_win32") // 74 -class VkMemoryWin32HandlePropertiesKHR { - VkStructureType sType - void* pNext - u32 memoryTypeBits -} - -@extension("VK_KHR_external_memory_win32") // 74 -class VkMemoryGetWin32HandleInfoKHR { - VkStructureType sType - void* pNext - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_external_memory_fd") // 75 -class VkImportMemoryFdInfoKHR { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBitsKHR handleType - int fd -} - -@extension("VK_KHR_external_memory_fd") // 75 -class VkMemoryFdPropertiesKHR { - VkStructureType sType - void* pNext - u32 memoryTypeBits -} - -@extension("VK_KHR_external_memory_fd") // 75 -class VkMemoryGetFdInfoKHR { - VkStructureType sType - void* pNext - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_win32_keyed_mutex") // 76 -class VkWin32KeyedMutexAcquireReleaseInfoKHR { - VkStructureType sType - const void* pNext - u32 acquireCount - const VkDeviceMemory* pAcquireSyncs - const u64* pAcquireKeys - const u32* pAcquireTimeouts - u32 releaseCount - const VkDeviceMemory* pReleaseSyncs - const u64* pReleaseKeys -} - -@extension("VK_KHR_external_semaphore_capabilities") // 77 -class VkPhysicalDeviceExternalSemaphoreInfoKHR { - VkStructureType sType - const void* pNext - VkExternalSemaphoreHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_external_semaphore_capabilities") // 77 -class VkExternalSemaphorePropertiesKHR { - VkStructureType sType - void* pNext - VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes - VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes - VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures -} - -@extension("VK_KHR_external_semaphore") // 78 -class VkExportSemaphoreCreateInfoKHR { - VkStructureType sType - const void* pNext - VkExternalSemaphoreHandleTypeFlagsKHR handleTypes -} - -@extension("VK_KHR_external_semaphore_win32") // 79 -class VkImportSemaphoreWin32HandleInfoKHR { - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkSemaphoreImportFlagsKHR flags - VkExternalSemaphoreHandleTypeFlagsKHR handleType - platform.HANDLE handle - platform.LPCWSTR name -} - -@extension("VK_KHR_external_semaphore_win32") // 79 -class VkExportSemaphoreWin32HandleInfoKHR { - VkStructureType sType - const void* pNext - const platform.SECURITY_ATTRIBUTES* pAttributes - platform.DWORD dwAccess - platform.LPCWSTR name -} - -@extension("VK_KHR_external_semaphore_win32") // 79 -class VkD3D12FenceSubmitInfoKHR { - VkStructureType sType - const void* pNext - u32 waitSemaphoreValuesCount - const u64* pWaitSemaphoreValues - u32 signalSemaphoreValuesCount - const u64* pSignalSemaphoreValues -} - -@extension("VK_KHR_external_semaphore_win32") // 79 -class VkSemaphoreGetWin32HandleInfoKHR { - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_external_semaphore_fd") // 80 -class VkImportSemaphoreFdInfoKHR { - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkSemaphoreImportFlagsKHR flags - VkExternalSemaphoreHandleTypeFlagBitsKHR handleType - s32 fd -} - -@extension("VK_KHR_external_semaphore_fd") // 80 -class VkSemaphoreGetFdInfoKHR { - VkStructureType sType - const void* pNext - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_push_descriptor") // 81 -class VkPhysicalDevicePushDescriptorPropertiesKHR { - VkStructureType sType - void* pNext - u32 maxPushDescriptors -} - -@extension("VK_EXT_conditional_rendering") // 82 -class VkConditionalRenderingBeginInfoEXT { - VkStructureType sType - const void* pNext - VkBuffer buffer - VkDeviceSize offset - VkConditionalRenderingFlagsEXT flags -} - -@extension("VK_EXT_conditional_rendering") // 82 -class VkPhysicalDeviceConditionalRenderingFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 conditionalRendering - VkBool32 inheritedConditionalRendering -} - -@extension("VK_EXT_conditional_rendering") // 82 -class VkCommandBufferInheritanceConditionalRenderingInfoEXT { - VkStructureType sType - const void* pNext - VkBool32 conditionalRenderingEnable -} - -@extension("VK_KHR_shader_float16_int8") // 83 -class VkPhysicalDeviceFloat16Int8FeaturesKHR { - VkStructureType sType - void* pNext - VkBool32 shaderFloat16 - VkBool32 shaderInt8 -} - -@extension("VK_KHR_16bit_storage") // 84 -class VkPhysicalDevice16BitStorageFeaturesKHR { - VkStructureType sType - void* pNext - VkBool32 storageBuffer16BitAccess - VkBool32 uniformAndStorageBuffer16BitAccess - VkBool32 storagePushConstant16 - VkBool32 storageInputOutput16 -} - -@extension("VK_KHR_incremental_present") // 85 -class VkRectLayerKHR { - VkOffset2D offset - VkExtent2D extent - u32 layer -} - -@extension("VK_KHR_incremental_present") // 85 -class VkPresentRegionKHR { - u32 rectangleCount - const VkRectLayerKHR* pRectangles -} - -@extension("VK_KHR_incremental_present") // 85 -class VkPresentRegionsKHR { - VkStructureType sType - const void* pNext - u32 swapchainCount - const VkPresentRegionKHR* pRegions -} - -@extension("VK_KHR_descriptor_update_template") // 86 -class VkDescriptorUpdateTemplateEntryKHR { - u32 dstBinding - u32 dstArrayElement - u32 descriptorCount - VkDescriptorType descriptorType - platform.size_t offset - platform.size_t stride -} - -@extension("VK_KHR_descriptor_update_template") // 86 -class VkDescriptorUpdateTemplateCreateInfoKHR { - VkStructureType sType - void* pNext - VkDescriptorUpdateTemplateCreateFlagsKHR flags - u32 descriptorUpdateEntryCount - const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries - VkDescriptorUpdateTemplateTypeKHR templateType - VkDescriptorSetLayout descriptorSetLayout - VkPipelineBindPoint pipelineBindPoint - VkPipelineLayout pipelineLayout - u32 set -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkDeviceGeneratedCommandsFeaturesNVX { - VkStructureType sType - const void* pNext - VkBool32 computeBindingPointSupport -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkDeviceGeneratedCommandsLimitsNVX { - VkStructureType sType - const void* pNext - u32 maxIndirectCommandsLayoutTokenCount - u32 maxObjectEntryCounts - u32 minSequenceCountBufferOffsetAlignment - u32 minSequenceIndexBufferOffsetAlignment - u32 minCommandsTokenBufferOffsetAlignment -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkIndirectCommandsTokenNVX { - VkIndirectCommandsTokenTypeNVX tokenType - VkBuffer buffer - VkDeviceSize offset -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkIndirectCommandsLayoutTokenNVX { - VkIndirectCommandsTokenTypeNVX tokenType - u32 bindingUnit - u32 dynamicCount - u32 divisor -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkIndirectCommandsLayoutCreateInfoNVX { - VkStructureType sType - const void* pNext - VkPipelineBindPoint pipelineBindPoint - VkIndirectCommandsLayoutUsageFlagsNVX flags - u32 tokenCount - const VkIndirectCommandsLayoutTokenNVX* pTokens -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkCmdProcessCommandsInfoNVX { - VkStructureType sType - const void* pNext - VkObjectTableNVX objectTable - VkIndirectCommandsLayoutNVX indirectCommandsLayout - u32 indirectCommandsTokenCount - const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens - u32 maxSequencesCount - VkCommandBuffer targetCommandBuffer - VkBuffer sequencesCountBuffer - VkDeviceSize sequencesCountOffset - VkBuffer sequencesIndexBuffer - VkDeviceSize sequencesIndexOffset -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkCmdReserveSpaceForCommandsInfoNVX { - VkStructureType sType - const void* pNext - VkObjectTableNVX objectTable - VkIndirectCommandsLayoutNVX indirectCommandsLayout - u32 maxSequencesCount -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkObjectTableCreateInfoNVX { - VkStructureType sType - const void* pNext - u32 objectCount - const VkObjectEntryTypeNVX* pObjectEntryTypes - const u32* pObjectEntryCounts - const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags - u32 maxUniformBuffersPerDescriptor - u32 maxStorageBuffersPerDescriptor - u32 maxStorageImagesPerDescriptor - u32 maxSampledImagesPerDescriptor - u32 maxPipelineLayouts -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkObjectTableEntryNVX { - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkObjectTablePipelineEntryNVX { - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipeline pipeline -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkObjectTableDescriptorSetEntryNVX { - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipelineLayout pipelineLayout - VkDescriptorSet descriptorSet -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkObjectTableVertexBufferEntryNVX { - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkBuffer buffer -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkObjectTableIndexBufferEntryNVX { - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkBuffer buffer - VkIndexType indexType -} - -@extension("VK_NVX_device_generated_commands") // 87 -class VkObjectTablePushConstantEntryNVX { - VkObjectEntryTypeNVX type - VkObjectEntryUsageFlagsNVX flags - VkPipelineLayout pipelineLayout - VkShaderStageFlags stageFlags -} - -@extension("VK_NV_clip_space_w_scaling") // 88 -class VkViewportWScalingNV { - f32 xcoeff - f32 ycoeff -} - -@extension("VK_NV_clip_space_w_scaling") // 88 -class VkPipelineViewportWScalingStateCreateInfoNV { - VkStructureType sType - const void* pNext - VkBool32 viewportWScalingEnable - u32 viewportCount - const VkViewportWScalingNV* pViewportWScalings -} - -@extension("VK_EXT_display_surface_counter") // 91 -class VkSurfaceCapabilities2EXT { - VkStructureType sType - void* pNext - u32 minImageCount - u32 maxImageCount - VkExtent2D currentExtent - VkExtent2D minImageExtent - VkExtent2D maxImageExtent - u32 maxImageArrayLayers - VkSurfaceTransformFlagsKHR supportedTransforms - VkSurfaceTransformFlagBitsKHR currentTransform - VkCompositeAlphaFlagsKHR supportedCompositeAlpha - VkImageUsageFlags supportedUsageFlags - VkSurfaceCounterFlagsEXT supportedSurfaceCounters -} - -@extension("VK_EXT_display_control") // 92 -class VkDisplayPowerInfoEXT { - VkStructureType sType - const void* pNext - VkDisplayPowerStateEXT powerState -} - -@extension("VK_EXT_display_control") // 92 -class VkDeviceEventInfoEXT { - VkStructureType sType - const void* pNext - VkDeviceEventTypeEXT deviceEvent -} - -@extension("VK_EXT_display_control") // 92 -class VkDisplayEventInfoEXT { - VkStructureType sType - const void* pNext - VkDisplayEventTypeEXT displayEvent -} - -@extension("VK_EXT_display_control") // 92 -class VkSwapchainCounterCreateInfoEXT { - VkStructureType sType - const void* pNext - VkSurfaceCounterFlagsEXT surfaceCounters -} - -@extension("VK_GOOGLE_display_timing") // 93 -class VkRefreshCycleDurationGOOGLE { - u64 refreshDuration -} - -@extension("VK_GOOGLE_display_timing") // 93 -class VkPastPresentationTimingGOOGLE { - u32 presentID - u64 desiredPresentTime - u64 actualPresentTime - u64 earliestPresentTime - u64 presentMargin -} - -@extension("VK_GOOGLE_display_timing") // 93 -class VkPresentTimeGOOGLE { - u32 presentID - u64 desiredPresentTime -} - -@extension("VK_GOOGLE_display_timing") // 93 -class VkPresentTimesInfoGOOGLE { - VkStructureType sType - const void* pNext - u32 swapchainCount - const VkPresentTimeGOOGLE* pTimes -} - -@extension("VK_NVX_multiview_per_view_attributes") // 98 -class VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - VkStructureType sType - void* pNext - VkBool32 perViewPositionAllComponents -} - -@extension("VK_NV_viewport_swizzle") // 99 -class VkViewportSwizzleNV { - VkViewportCoordinateSwizzleNV x - VkViewportCoordinateSwizzleNV y - VkViewportCoordinateSwizzleNV z - VkViewportCoordinateSwizzleNV w -} - -@extension("VK_NV_viewport_swizzle") // 99 -class VkPipelineViewportSwizzleStateCreateInfoNV { - VkStructureType sType - const void* pNext - VkPipelineViewportSwizzleStateCreateFlagsNV flags - u32 viewportCount - const VkViewportSwizzleNV* pViewportSwizzles -} - -@extension("VK_EXT_discard_rectangles") // 100 -class VkPhysicalDeviceDiscardRectanglePropertiesEXT { - VkStructureType sType - void* pNext - u32 maxDiscardRectangles -} - -@extension("VK_EXT_discard_rectangles") // 100 -class VkPipelineDiscardRectangleStateCreateInfoEXT { - VkStructureType sType - const void* pNext - VkPipelineDiscardRectangleStateCreateFlagsEXT flags - VkDiscardRectangleModeEXT discardRectangleMode - u32 discardRectangleCount - const VkRect2D* pDiscardRectangles -} - -@extension("VK_EXT_conservative_rasterization") // 102 -class VkPhysicalDeviceConservativeRasterizationPropertiesEXT { - VkStructureType sType - void* pNext - f32 primitiveOverestimationSize - f32 maxExtraPrimitiveOverestimationSize - f32 extraPrimitiveOverestimationSizeGranularity - VkBool32 primitiveUnderestimation - VkBool32 conservativePointAndLineRasterization - VkBool32 degenerateTrianglesRasterized - VkBool32 degenerateLinesRasterized - VkBool32 fullyCoveredFragmentShaderInputVariable - VkBool32 conservativeRasterizationPostDepthCoverage -} - -@extension("VK_EXT_conservative_rasterization") // 102 -class VkPipelineRasterizationConservativeStateCreateInfoEXT { - VkStructureType sType - const void* pNext - VkPipelineRasterizationConservativeStateCreateFlagsEXT flags - VkConservativeRasterizationModeEXT conservativeRasterizationMode - f32 extraPrimitiveOverestimationSize -} - -@extension("VK_EXT_hdr_metadata") // 106 -class VkXYColorEXT { - f32 x - f32 y -} - -@extension("VK_EXT_hdr_metadata") // 106 -class VkHdrMetadataEXT { - VkStructureType sType - const void* pNext - VkXYColorEXT displayPrimaryRed - VkXYColorEXT displayPrimaryGreen - VkXYColorEXT displayPrimaryBlue - VkXYColorEXT whitePoint - f32 maxLuminance - f32 minLuminance - f32 maxContentLightLevel - f32 maxFrameAverageLightLevel -} - -@extension("VK_KHR_create_renderpass2") // 110 -class VkAttachmentDescription2KHR { - VkStructureType sType - const void* pNext - VkAttachmentDescriptionFlags flags - VkFormat format - VkSampleCountFlagBits samples - VkAttachmentLoadOp loadOp - VkAttachmentStoreOp storeOp - VkAttachmentLoadOp stencilLoadOp - VkAttachmentStoreOp stencilStoreOp - VkImageLayout initialLayout - VkImageLayout finalLayout -} - -@extension("VK_KHR_create_renderpass2") // 110 -class VkAttachmentReference2KHR { - VkStructureType sType - const void* pNext - u32 attachment - VkImageLayout layout - VkImageAspectFlags aspectMask -} - -@extension("VK_KHR_create_renderpass2") // 110 -class VkSubpassDescription2KHR { - VkStructureType sType - const void* pNext - VkSubpassDescriptionFlags flags - VkPipelineBindPoint pipelineBindPoint - u32 viewMask - u32 inputAttachmentCount - const VkAttachmentReference2KHR* pInputAttachments - u32 colorAttachmentCount - const VkAttachmentReference2KHR* pColorAttachments - const VkAttachmentReference2KHR* pResolveAttachments - const VkAttachmentReference2KHR* pDepthStencilAttachment - u32 preserveAttachmentCount - const u32* pPreserveAttachments -} - -@extension("VK_KHR_create_renderpass2") // 110 -class VkSubpassDependency2KHR { - VkStructureType sType - const void* pNext - u32 srcSubpass - u32 dstSubpass - VkPipelineStageFlags srcStageMask - VkPipelineStageFlags dstStageMask - VkAccessFlags srcAccessMask - VkAccessFlags dstAccessMask - VkDependencyFlags dependencyFlags - s32 viewOffset -} - -@extension("VK_KHR_create_renderpass2") // 110 -class VkRenderPassCreateInfo2KHR { - VkStructureType sType - const void* pNext - VkRenderPassCreateFlags flags - u32 attachmentCount - const VkAttachmentDescription2KHR* pAttachments - u32 subpassCount - const VkSubpassDescription2KHR* pSubpasses - u32 dependencyCount - const VkSubpassDependency2KHR* pDependencies - u32 correlatedViewMaskCount - const u32* pCorrelatedViewMasks -} - -@extension("VK_KHR_create_renderpass2") // 110 -class VkSubpassBeginInfoKHR { - VkStructureType sType - const void* pNext - VkSubpassContents contents -} - -@extension("VK_KHR_create_renderpass2") // 110 -class VkSubpassEndInfoKHR { - VkStructureType sType - const void* pNext -} - -@extension("VK_KHR_shared_presentable_image") // 112 -class VkSharedPresentSurfaceCapabilitiesKHR { - VkStructureType sType - const void* pNext - VkImageUsageFlags sharedPresentSupportedUsageFlags -} - -@extension("VK_KHR_external_fence_capabilities") // 113 -class VkPhysicalDeviceExternalFenceInfoKHR { - VkStructureType sType - const void* pNext - VkExternalFenceHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_external_fence_capabilities") // 113 -class VkExternalFencePropertiesKHR { - VkStructureType sType - void* pNext - VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes - VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes - VkExternalFenceFeatureFlagsKHR externalFenceFeatures -} - -@extension("VK_KHR_external_fence") // 114 -class VkExportFenceCreateInfoKHR { - VkStructureType sType - const void* pNext - VkExternalFenceHandleTypeFlagsKHR handleTypes -} - -@extension("VK_KHR_external_fence_win32") // 115 -class VkImportFenceWin32HandleInfoKHR { - VkStructureType sType - const void* pNext - VkFence fence - VkFenceImportFlagsKHR flags - VkExternalFenceHandleTypeFlagBitsKHR handleType - platform.HANDLE handle - platform.LPCWSTR name -} - -@extension("VK_KHR_external_fence_win32") // 115 -class VkExportFenceWin32HandleInfoKHR { - VkStructureType sType - const void* pNext - const platform.SECURITY_ATTRIBUTES* pAttributes - platform.DWORD dwAccess - platform.LPCWSTR name -} - -@extension("VK_KHR_external_fence_win32") // 115 -class VkFenceGetWin32HandleInfoKHR { - VkStructureType sType - const void* pNext - VkFence fence - VkExternalFenceHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_external_fence_fd") // 116 -class VkImportFenceFdInfoKHR { - VkStructureType sType - const void* pNext - VkFence fence - VkFenceImportFlagsKHR flags - VkExternalFenceHandleTypeFlagBitsKHR handleType - int fd -} - -@extension("VK_KHR_external_fence_fd") // 116 -class VkFenceGetFdInfoKHR { - VkStructureType sType - const void* pNext - VkFence fence - VkExternalFenceHandleTypeFlagBitsKHR handleType -} - -@extension("VK_KHR_maintenance2") // 118 -class VkPhysicalDevicePointClippingPropertiesKHR { - VkStructureType sType - void* pNext - VkPointClippingBehaviorKHR pointClippingBehavior -} - -@extension("VK_KHR_maintenance2") // 118 -class VkInputAttachmentAspectReferenceKHR { - u32 subpass - u32 inputAttachmentIndex - VkImageAspectFlags aspectMask -} - -@extension("VK_KHR_maintenance2") // 118 -class VkRenderPassInputAttachmentAspectCreateInfoKHR { - VkStructureType sType - const void* pNext - u32 aspectReferenceCount - const VkInputAttachmentAspectReferenceKHR* pAspectReferences -} - -@extension("VK_KHR_maintenance2") // 118 -class VkImageViewUsageCreateInfoKHR { - VkStructureType sType - const void* pNext - VkImageUsageFlags usage -} - -@extension("VK_KHR_maintenance2") // 118 -class VkPipelineTessellationDomainOriginStateCreateInfoKHR { - VkStructureType sType - const void* pNext - VkTessellationDomainOriginKHR domainOrigin -} - -@extension("VK_KHR_get_surface_capabilities2") // 120 -class VkPhysicalDeviceSurfaceInfo2KHR { - VkStructureType sType - const void* pNext - VkSurfaceKHR surface -} - -@extension("VK_KHR_get_surface_capabilities2") // 120 -class VkSurfaceCapabilities2KHR { - VkStructureType sType - void* pNext - VkSurfaceCapabilitiesKHR surfaceCapabilities -} - -@extension("VK_KHR_get_surface_capabilities2") // 120 -class VkSurfaceFormat2KHR { - VkStructureType sType - void* pNext - VkSurfaceFormatKHR surfaceFormat -} - -@extension("VK_KHR_variable_pointers") // 121 -class VkPhysicalDeviceVariablePointerFeaturesKHR { - VkStructureType sType - void* pNext - VkBool32 variablePointersStorageBuffer - VkBool32 variablePointers -} - -@extension("VK_KHR_display_properties2") // 122 -class VkDisplayProperties2KHR { - VkStructureType sType - void* pNext - VkDisplayPropertiesKHR displayProperties -} - -@extension("VK_KHR_display_properties2") // 122 -class VkDisplayPlaneProperties2KHR { - VkStructureType sType - void* pNext - VkDisplayPlanePropertiesKHR displayPlaneProperties -} - -@extension("VK_KHR_display_properties2") // 122 -class VkDisplayModeProperties2KHR { - VkStructureType sType - void* pNext - VkDisplayModePropertiesKHR displayModeProperties -} - -@extension("VK_KHR_display_properties2") // 122 -class VkDisplayPlaneInfo2KHR { - VkStructureType sType - const void* pNext - VkDisplayModeKHR mode - u32 planeIndex -} - -@extension("VK_KHR_display_properties2") // 122 -class VkDisplayPlaneCapabilities2KHR { - VkStructureType sType - void* pNext - VkDisplayPlaneCapabilitiesKHR capabilities -} - -@extension("VK_MVK_ios_surface") // 123 -class VkIOSSurfaceCreateInfoMVK { - VkStructureType sType - const void* pNext - VkIOSSurfaceCreateFlagsMVK flags - const void* pView -} - -@extension("VK_MVK_macos_surface") // 124 -class VkMacOSSurfaceCreateInfoMVK { - VkStructureType sType - const void* pNext - VkMacOSSurfaceCreateFlagsMVK flags - const void* pView -} - -@extension("VK_KHR_dedicated_allocation") // 128 -class VkMemoryDedicatedRequirementsKHR { - VkStructureType sType - void* pNext - VkBool32 prefersDedicatedAllocation - VkBool32 requiresDedicatedAllocation -} - -@extension("VK_KHR_dedicated_allocation") // 128 -class VkMemoryDedicatedAllocateInfoKHR { - VkStructureType sType - const void* pNext - VkImage image - VkBuffer buffer -} - -@extension("VK_EXT_debug_utils") // 129 -class VkDebugUtilsObjectNameInfoEXT { - VkStructureType sType - const void* pNext - VkObjectType objectType - u64 objectHandle - const char* pObjectName -} - -@extension("VK_EXT_debug_utils") // 129 -class VkDebugUtilsObjectTagInfoEXT { - VkStructureType sType - const void* pNext - VkObjectType objectType - u64 objectHandle - u64 tagName - platform.size_t tagSize - const void* pTag -} - -@extension("VK_EXT_debug_utils") // 129 -class VkDebugUtilsLabelEXT { - VkStructureType sType - const void* pNext - const char* pLabelName - f32[4] color -} - -@extension("VK_EXT_debug_utils") // 129 -class VkDebugUtilsMessengerCallbackDataEXT { - VkStructureType sType - const void* pNext - VkDebugUtilsMessengerCallbackDataFlagsEXT flags - const char* pMessageIdName - s32 messageIdNumber - const char* pMessage - u32 queueLabelCount - const VkDebugUtilsLabelEXT* pQueueLabels - u32 cmdBufLabelCount - const VkDebugUtilsLabelEXT* pCmdBufLabels - u32 objectCount - const VkDebugUtilsObjectNameInfoEXT* pObjects -} - -@extension("VK_EXT_debug_utils") // 129 -class VkDebugUtilsMessengerCreateInfoEXT { - VkStructureType sType - const void* pNext - VkDebugUtilsMessengerCreateFlagsEXT flags - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity - VkDebugUtilsMessageTypeFlagsEXT messageTypes - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback - void* pUserData -} - -@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 131 -class VkAndroidHardwareBufferUsageANDROID { - VkStructureType sType - void* pNext - u64 androidHardwareBufferUsage -} - -@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 -class VkAndroidHardwareBufferPropertiesANDROID { - VkStructureType sType - void* pNext - VkDeviceSize allocationSize - u32 memoryTypeBits -} - -@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 -class VkAndroidHardwareBufferFormatPropertiesANDROID { - VkStructureType sType - void* pNext - VkFormat format - u64 externalFormat - VkFormatFeatureFlags formatFeatures - VkComponentMapping samplerYcbcrConversionComponents - VkSamplerYcbcrModelConversion suggestedYcbcrModel - VkSamplerYcbcrRange suggestedYcbcrRange - VkChromaLocation suggestedXChromaOffset - VkChromaLocation suggestedYChromaOffset -} - -@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 -class VkImportAndroidHardwareBufferInfoANDROID { - VkStructureType sType - const void* pNext - platform.AHardwareBuffer* buffer -} - -@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 -class VkMemoryGetAndroidHardwareBufferInfoANDROID { - VkStructureType sType - const void* pNext - VkDeviceMemory memory -} - -@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 -class VkExternalFormatANDROID { - VkStructureType sType - void* pNext - u64 externalFormat -} - -@extension("VK_EXT_sampler_filter_minmax") // 131 -class VkSamplerReductionModeCreateInfoEXT { - VkStructureType sType - const void* pNext - VkSamplerReductionModeEXT reductionMode -} - -@extension("VK_EXT_sampler_filter_minmax") // 131 -class VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { - VkStructureType sType - void* pNext - VkBool32 filterMinmaxSingleComponentFormats - VkBool32 filterMinmaxImageComponentMapping -} - -@extension("VK_EXT_inline_uniform_block") // 139 -class VkPhysicalDeviceInlineUniformBlockFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 inlineUniformBlock - VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind -} - -@extension("VK_EXT_inline_uniform_block") // 139 -class VkPhysicalDeviceInlineUniformBlockPropertiesEXT { - VkStructureType sType - void* pNext - u32 maxInlineUniformBlockSize - u32 maxPerStageDescriptorInlineUniformBlocks - u32 maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks - u32 maxDescriptorSetInlineUniformBlocks - u32 maxDescriptorSetUpdateAfterBindInlineUniformBlocks -} - -@extension("VK_EXT_inline_uniform_block") // 139 -class VkWriteDescriptorSetInlineUniformBlockEXT { - VkStructureType sType - const void* pNext - u32 dataSize - const void* pData -} - -@extension("VK_EXT_inline_uniform_block") // 139 -class VkDescriptorPoolInlineUniformBlockCreateInfoEXT { - VkStructureType sType - const void* pNext - u32 maxInlineUniformBlockBindings -} - -@extension("VK_EXT_sample_locations") // 144 -class VkSampleLocationEXT { - f32 x - f32 y -} - -@extension("VK_EXT_sample_locations") // 144 -class VkSampleLocationsInfoEXT { - VkStructureType sType - const void* pNext - VkSampleCountFlagBits sampleLocationsPerPixel - VkExtent2D sampleLocationGridSize - u32 sampleLocationsCount - const VkSampleLocationEXT* pSampleLocations -} - -@extension("VK_EXT_sample_locations") // 144 -class VkAttachmentSampleLocationsEXT { - u32 attachmentIndex - VkSampleLocationsInfoEXT sampleLocationsInfo -} - -@extension("VK_EXT_sample_locations") // 144 -class VkSubpassSampleLocationsEXT { - u32 subpassIndex - VkSampleLocationsInfoEXT sampleLocationsInfo -} - -@extension("VK_EXT_sample_locations") // 144 -class VkRenderPassSampleLocationsBeginInfoEXT { - VkStructureType sType - const void* pNext - u32 attachmentInitialSampleLocationsCount - const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations - u32 postSubpassSampleLocationsCount - const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations -} - -@extension("VK_EXT_sample_locations") // 144 -class VkPipelineSampleLocationsStateCreateInfoEXT { - VkStructureType sType - const void* pNext - VkBool32 sampleLocationsEnable - VkSampleLocationsInfoEXT sampleLocationsInfo -} - -@extension("VK_EXT_sample_locations") // 144 -class VkPhysicalDeviceSampleLocationsPropertiesEXT { - VkStructureType sType - void* pNext - VkSampleCountFlags sampleLocationSampleCounts - VkExtent2D maxSampleLocationGridSize - f32[2] sampleLocationCoordinateRange - u32 sampleLocationSubPixelBits - VkBool32 variableSampleLocations -} - -@extension("VK_EXT_sample_locations") // 144 -class VkMultisamplePropertiesEXT { - VkStructureType sType - void* pNext - VkExtent2D maxSampleLocationGridSize -} - -@extension("VK_KHR_get_memory_requirements2") // 147 -class VkBufferMemoryRequirementsInfo2KHR { - VkStructureType sType - const void* pNext - VkBuffer buffer -} - -@extension("VK_KHR_get_memory_requirements2") // 147 -class VkImageMemoryRequirementsInfo2KHR { - VkStructureType sType - const void* pNext - VkImage image -} - -@extension("VK_KHR_get_memory_requirements2") // 147 -class VkImageSparseMemoryRequirementsInfo2KHR { - VkStructureType sType - const void* pNext - VkImage image -} - -@extension("VK_KHR_get_memory_requirements2") // 147 -class VkMemoryRequirements2KHR { - VkStructureType sType - void* pNext - VkMemoryRequirements memoryRequirements -} - -@extension("VK_KHR_get_memory_requirements2") // 147 -class VkSparseImageMemoryRequirements2KHR { - VkStructureType sType - void* pNext - VkSparseImageMemoryRequirements memoryRequirements -} - -@extension("VK_KHR_image_format_list") // 148 -class VkImageFormatListCreateInfoKHR { - VkStructureType sType - const void* pNext - u32 viewFormatCount - const VkFormat* pViewFormats -} - -@extension("VK_EXT_blend_operation_advanced") // 149 -class VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 advancedBlendCoherentOperations -} - -@extension("VK_EXT_blend_operation_advanced") // 149 -class VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { - VkStructureType sType - void* pNext - u32 advancedBlendMaxColorAttachments - VkBool32 advancedBlendIndependentBlend - VkBool32 advancedBlendNonPremultipliedSrcColor - VkBool32 advancedBlendNonPremultipliedDstColor - VkBool32 advancedBlendCorrelatedOverlap - VkBool32 advancedBlendAllOperations -} - -@extension("VK_EXT_blend_operation_advanced") // 149 -class VkPipelineColorBlendAdvancedStateCreateInfoEXT { - VkStructureType sType - const void* pNext - VkBool32 srcPremultiplied - VkBool32 dstPremultiplied - VkBlendOverlapEXT blendOverlap -} - -@extension("VK_NV_fragment_coverage_to_color") // 150 -class VkPipelineCoverageToColorStateCreateInfoNV { - VkStructureType sType - const void* pNext - VkPipelineCoverageToColorStateCreateFlagsNV flags - VkBool32 coverageToColorEnable - u32 coverageToColorLocation -} - -@extension("VK_NV_framebuffer_mixed_samples") // 153 -class VkPipelineCoverageModulationStateCreateInfoNV { - VkStructureType sType - const void* pNext - VkPipelineCoverageModulationStateCreateFlagsNV flags - VkCoverageModulationModeNV coverageModulationMode - VkBool32 coverageModulationTableEnable - u32 coverageModulationTableCount - const f32* pCoverageModulationTable -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -class VkSamplerYcbcrConversionCreateInfoKHR { - VkStructureType sType - const void* pNext - VkFormat format - VkSamplerYcbcrModelConversionKHR ycbcrModel - VkSamplerYcbcrRangeKHR ycbcrRange - VkComponentMapping components - VkChromaLocationKHR xChromaOffset - VkChromaLocationKHR yChromaOffset - VkFilter chromaFilter - VkBool32 forceExplicitReconstruction -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -class VkSamplerYcbcrConversionInfoKHR { - VkStructureType sType - const void* pNext - VkSamplerYcbcrConversionKHR conversion -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -class VkBindImagePlaneMemoryInfoKHR { - VkStructureType sType - const void* pNext - VkImageAspectFlagBits planeAspect -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -class VkImagePlaneMemoryRequirementsInfoKHR { - VkStructureType sType - const void* pNext - VkImageAspectFlagBits planeAspect -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -class VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR { - VkStructureType sType - void* pNext - VkBool32 samplerYcbcrConversion -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -class VkSamplerYcbcrConversionImageFormatPropertiesKHR { - VkStructureType sType - void* pNext - u32 combinedImageSamplerDescriptorCount -} - -@extension("VK_KHR_bind_memory2") // 158 -class VkBindBufferMemoryInfoKHR { - VkStructureType sType - const void* pNext - VkBuffer buffer - VkDeviceMemory memory - VkDeviceSize memoryOffset -} - -@extension("VK_KHR_bind_memory2") // 158 -class VkBindImageMemoryInfoKHR { - VkStructureType sType - const void* pNext - VkImage image - VkDeviceMemory memory - VkDeviceSize memoryOffset -} - -@extension("VK_EXT_image_drm_format_modifier") // 159 -class VkDrmFormatModifierPropertiesEXT { - u64 drmFormatModifier - u32 drmFormatModifierPlaneCount - VkFormatFeatureFlags drmFormatModifierTilingFeatures -} - -@extension("VK_EXT_image_drm_format_modifier") // 159 -class VkDrmFormatModifierPropertiesListEXT { - VkStructureType sType - void* pNext - u32 drmFormatModifierCount - VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties -} - -@extension("VK_EXT_image_drm_format_modifier") // 159 -class VkPhysicalDeviceImageDrmFormatModifierInfoEXT { - VkStructureType sType - const void* pNext - u64 drmFormatModifier - VkSharingMode sharingMode - u32 queueFamilyIndexCount - const u32* pQueueFamilyIndices -} - -@extension("VK_EXT_image_drm_format_modifier") // 159 -class VkImageDrmFormatModifierListCreateInfoEXT { - VkStructureType sType - const void* pNext - u32 drmFormatModifierCount - const u64* pDrmFormatModifiers -} - -@extension("VK_EXT_image_drm_format_modifier") // 159 -class VkImageDrmFormatModifierExplicitCreateInfoEXT { - VkStructureType sType - const void* pNext - u64 drmFormatModifier - u32 drmFormatModifierPlaneCount - const VkSubresourceLayout* pPlaneLayouts -} - -@extension("VK_EXT_image_drm_format_modifier") // 159 -class VkImageDrmFormatModifierPropertiesEXT { - VkStructureType sType - void* pNext - u64 drmFormatModifier -} - -@extension("VK_EXT_validation_cache") // 161 -class VkValidationCacheCreateInfoEXT { - VkStructureType sType - const void* pNext - VkValidationCacheCreateFlagsEXT flags - platform.size_t initialDataSize - const void* pInitialData -} - -@extension("VK_EXT_validation_cache") // 161 -class VkShaderModuleValidationCacheCreateInfoEXT { - VkStructureType sType - const void* pNext - VkValidationCacheEXT validationCache -} - -@extension("VK_EXT_descriptor_indexing") // 162 -class VkDescriptorSetLayoutBindingFlagsCreateInfoEXT { - VkStructureType sType - const void* pNext - u32 bindingCount - const VkDescriptorBindingFlagsEXT* pBindingFlags -} - -@extension("VK_EXT_descriptor_indexing") // 162 -class VkPhysicalDeviceDescriptorIndexingFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 shaderInputAttachmentArrayDynamicIndexing - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing - VkBool32 shaderUniformBufferArrayNonUniformIndexing - VkBool32 shaderSampledImageArrayNonUniformIndexing - VkBool32 shaderStorageBufferArrayNonUniformIndexing - VkBool32 shaderStorageImageArrayNonUniformIndexing - VkBool32 shaderInputAttachmentArrayNonUniformIndexing - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing - VkBool32 descriptorBindingUniformBufferUpdateAfterBind - VkBool32 descriptorBindingSampledImageUpdateAfterBind - VkBool32 descriptorBindingStorageImageUpdateAfterBind - VkBool32 descriptorBindingStorageBufferUpdateAfterBind - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind - VkBool32 descriptorBindingUpdateUnusedWhilePending - VkBool32 descriptorBindingPartiallyBound - VkBool32 descriptorBindingVariableDescriptorCount - VkBool32 runtimeDescriptorArray -} - -@extension("VK_EXT_descriptor_indexing") // 162 -class VkPhysicalDeviceDescriptorIndexingPropertiesEXT { - VkStructureType sType - void* pNext - u32 maxUpdateAfterBindDescriptorsInAllPools - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative - VkBool32 shaderSampledImageArrayNonUniformIndexingNative - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative - VkBool32 shaderStorageImageArrayNonUniformIndexingNative - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative - VkBool32 robustBufferAccessUpdateAfterBind - VkBool32 quadDivergentImplicitLod - u32 maxPerStageDescriptorUpdateAfterBindSamplers - u32 maxPerStageDescriptorUpdateAfterBindUniformBuffers - u32 maxPerStageDescriptorUpdateAfterBindStorageBuffers - u32 maxPerStageDescriptorUpdateAfterBindSampledImages - u32 maxPerStageDescriptorUpdateAfterBindStorageImages - u32 maxPerStageDescriptorUpdateAfterBindInputAttachments - u32 maxPerStageUpdateAfterBindResources - u32 maxDescriptorSetUpdateAfterBindSamplers - u32 maxDescriptorSetUpdateAfterBindUniformBuffers - u32 maxDescriptorSetUpdateAfterBindUniformBuffersDynamic - u32 maxDescriptorSetUpdateAfterBindStorageBuffers - u32 maxDescriptorSetUpdateAfterBindStorageBuffersDynamic - u32 maxDescriptorSetUpdateAfterBindSampledImages - u32 maxDescriptorSetUpdateAfterBindStorageImages - u32 maxDescriptorSetUpdateAfterBindInputAttachments -} - -@extension("VK_EXT_descriptor_indexing") // 162 -class VkDescriptorSetVariableDescriptorCountAllocateInfoEXT { - VkStructureType sType - const void* pNext - u32 descriptorSetCount - const u32* pDescriptorCounts -} - -@extension("VK_EXT_descriptor_indexing") // 162 -class VkDescriptorSetVariableDescriptorCountLayoutSupportEXT { - VkStructureType sType - void* pNext - u32 maxVariableDescriptorCount -} - -@extension("VK_NV_shading_rate_image") // 165 -class VkShadingRatePaletteNV { - u32 shadingRatePaletteEntryCount - const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries -} - -@extension("VK_NV_shading_rate_image") // 165 -class VkPipelineViewportShadingRateImageStateCreateInfoNV { - VkStructureType sType - const void* pNext - VkBool32 shadingRateImageEnable - u32 viewportCount - const VkShadingRatePaletteNV* pShadingRatePalettes -} - -@extension("VK_NV_shading_rate_image") // 165 -class VkPhysicalDeviceShadingRateImageFeaturesNV { - VkStructureType sType - void* pNext - VkBool32 shadingRateImage - VkBool32 shadingRateCoarseSampleOrder -} - -@extension("VK_NV_shading_rate_image") // 165 -class VkPhysicalDeviceShadingRateImagePropertiesNV { - VkStructureType sType - void* pNext - VkExtent2D shadingRateTexelSize - u32 shadingRatePaletteSize - u32 shadingRateMaxCoarseSamples -} - -@extension("VK_NV_shading_rate_image") // 165 -class VkCoarseSampleLocationNV { - u32 pixelX - u32 pixelY - u32 sample -} - -@extension("VK_NV_shading_rate_image") // 165 -class VkCoarseSampleOrderCustomNV { - VkShadingRatePaletteEntryNV shadingRate - u32 sampleCount - u32 sampleLocationCount - const VkCoarseSampleLocationNV* pSampleLocations -} - -@extension("VK_NV_shading_rate_image") // 165 -class VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { - VkStructureType sType - const void* pNext - VkCoarseSampleOrderTypeNV sampleOrderType - u32 customSampleOrderCount - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders -} - -@extension("VK_NV_ray_tracing") // 166 -class VkRayTracingShaderGroupCreateInfoNV { - VkStructureType sType - const void* pNext - VkRayTracingShaderGroupTypeNV type - u32 generalShader - u32 closestHitShader - u32 anyHitShader - u32 intersectionShader -} - -@extension("VK_NV_ray_tracing") // 166 -class VkRayTracingPipelineCreateInfoNV { - VkStructureType sType - const void* pNext - VkPipelineCreateFlags flags - u32 stageCount - const VkPipelineShaderStageCreateInfo* pStages - u32 groupCount - const VkRayTracingShaderGroupCreateInfoNV* pGroups - u32 maxRecursionDepth - VkPipelineLayout layout - VkPipeline basePipelineHandle - s32 basePipelineIndex -} - -@extension("VK_NV_ray_tracing") // 166 -class VkGeometryTrianglesNV { - VkStructureType sType - const void* pNext - VkBuffer vertexData - VkDeviceSize vertexOffset - u32 vertexCount - VkDeviceSize vertexStride - VkFormat vertexFormat - VkBuffer indexData - VkDeviceSize indexOffset - u32 indexCount - VkIndexType indexType - VkBuffer transformData - VkDeviceSize transformOffset -} - -@extension("VK_NV_ray_tracing") // 166 -class VkGeometryAABBNV { - VkStructureType sType - const void* pNext - VkBuffer aabbData - u32 numAABBs - u32 stride - VkDeviceSize offset -} - -@extension("VK_NV_ray_tracing") // 166 -class VkGeometryDataNV { - VkGeometryTrianglesNV triangles - VkGeometryAABBNV aabbs -} - -@extension("VK_NV_ray_tracing") // 166 -class VkGeometryNV { - VkStructureType sType - const void* pNext - VkGeometryTypeNV geometryType - VkGeometryDataNV geometry - VkGeometryFlagsNV flags -} - -@extension("VK_NV_ray_tracing") // 166 -class VkAccelerationStructureInfoNV { - VkStructureType sType - const void* pNext - VkAccelerationStructureTypeNV type - VkBuildAccelerationStructureFlagsNV flags - u32 instanceCount - u32 geometryCount - const VkGeometryNV* pGeometries -} - -@extension("VK_NV_ray_tracing") // 166 -class VkAccelerationStructureCreateInfoNV { - VkStructureType sType - const void* pNext - VkDeviceSize compactedSize - VkAccelerationStructureInfoNV info -} - -@extension("VK_NV_ray_tracing") // 166 -class VkBindAccelerationStructureMemoryInfoNV { - VkStructureType sType - const void* pNext - VkAccelerationStructureNV accelerationStructure - VkDeviceMemory memory - VkDeviceSize memoryOffset - u32 deviceIndexCount - const u32* pDeviceIndices -} - -@extension("VK_NV_ray_tracing") // 166 -class VkDescriptorAccelerationStructureInfoNV { - VkStructureType sType - const void* pNext - u32 accelerationStructureCount - const VkAccelerationStructureNV* pAccelerationStructures -} - -@extension("VK_NV_ray_tracing") // 166 -class VkAccelerationStructureMemoryRequirementsInfoNV { - VkStructureType sType - const void* pNext - VkAccelerationStructureMemoryRequirementsTypeNV type - VkAccelerationStructureNV accelerationStructure -} - -@extension("VK_NV_ray_tracing") // 166 -class VkPhysicalDeviceRaytracingPropertiesNV { - VkStructureType sType - void* pNext - u32 shaderGroupHandleSize - u32 maxRecursionDepth - u32 maxShaderGroupStride - u32 shaderGroupBaseAlignment - u64 maxGeometryCount - u64 maxInstanceCount - u64 maxTriangleCount - u32 maxDescriptorSetAccelerationStructures -} - -@extension("VK_NV_representative_fragment_test") // 167 -class VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { - VkStructureType sType - void* pNext - VkBool32 representativeFragmentTest -} - -@extension("VK_NV_representative_fragment_test") // 167 -class VkPipelineRepresentativeFragmentTestStateCreateInfoNV { - VkStructureType sType - const void* pNext - VkBool32 representativeFragmentTestEnable -} - -@extension("VK_KHR_maintenance3") // 169 -class VkPhysicalDeviceMaintenance3PropertiesKHR { - VkStructureType sType - void* pNext - u32 maxPerSetDescriptors - VkDeviceSize maxMemoryAllocationSize -} - -@extension("VK_KHR_maintenance3") // 169 -class VkDescriptorSetLayoutSupportKHR { - VkStructureType sType - void* pNext - VkBool32 supported -} - -@extension("VK_EXT_global_priority") // 175 -class VkDeviceQueueGlobalPriorityCreateInfoEXT { - VkStructureType sType - const void* pNext - VkQueueGlobalPriorityEXT globalPriority -} - -@extension("VK_KHR_8bit_storage") // 178 -class VkPhysicalDevice8BitStorageFeaturesKHR { - VkStructureType sType - void* pNext - VkBool32 storageBuffer8BitAccess - VkBool32 uniformAndStorageBuffer8BitAccess - VkBool32 storagePushConstant8 -} - -@extension("VK_EXT_external_memory_host") // 179 -class VkImportMemoryHostPointerInfoEXT { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagBits handleType - void* pHostPointer -} - -@extension("VK_EXT_external_memory_host") // 179 -class VkMemoryHostPointerPropertiesEXT { - VkStructureType sType - void* pNext - u32 memoryTypeBits -} - -@extension("VK_EXT_external_memory_host") // 179 -class VkPhysicalDeviceExternalMemoryHostPropertiesEXT { - VkStructureType sType - void* pNext - VkDeviceSize minImportedHostPointerAlignment -} - -@extension("VK_KHR_shader_atomic_int64") // 181 -class VkPhysicalDeviceShaderAtomicInt64FeaturesKHR { - VkStructureType sType - void* pNext - VkBool32 shaderBufferInt64Atomics - VkBool32 shaderSharedInt64Atomics -} - -@extension("VK_EXT_calibrated_timestamps") // 185 -class VkCalibratedTimestampInfoEXT { - VkStructureType sType - const void* pNext - VkTimeDomainEXT timeDomain -} - -@extension("VK_AMD_shader_core_properties") // 186 -class VkPhysicalDeviceShaderCorePropertiesAMD { - VkStructureType sType - void* pNext - u32 shaderEngineCount - u32 shaderArraysPerEngineCount - u32 computeUnitsPerShaderArray - u32 simdPerComputeUnit - u32 wavefrontsPerSimd - u32 wavefrontSize - u32 sgprsPerSimd - u32 minSgprAllocation - u32 maxSgprAllocation - u32 sgprAllocationGranularity - u32 vgprsPerSimd - u32 minVgprAllocation - u32 maxVgprAllocation - u32 vgprAllocationGranularity -} - -@extension("VK_AMD_memory_overallocation_behavior") // 190 -class VkDeviceMemoryOverallocationCreateInfoAMD { - VkStructureType sType - const void* pNext - VkMemoryOverallocationBehaviorAMD overallocationBehavior -} - -@extension("VK_EXT_vertex_attribute_divisor") // 191 -class VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { - VkStructureType sType - void* pNext - u32 maxVertexAttribDivisor -} - -@extension("VK_EXT_vertex_attribute_divisor") // 191 -class VkVertexInputBindingDivisorDescriptionEXT { - u32 binding - u32 divisor -} - -@extension("VK_EXT_vertex_attribute_divisor") // 191 -class VkPipelineVertexInputDivisorStateCreateInfoEXT { - VkStructureType sType - const void* pNext - u32 vertexBindingDivisorCount - const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors -} - -@extension("VK_EXT_vertex_attribute_divisor") // 191 -class VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 vertexAttributeInstanceRateDivisor - VkBool32 vertexAttributeInstanceRateZeroDivisor -} - -@extension("VK_KHR_driver_properties") // 197 -class VkConformanceVersionKHR { - u8 major - u8 minor - u8 subminor - u8 patch -} - -@extension("VK_KHR_driver_properties") // 197 -class VkPhysicalDeviceDriverPropertiesKHR { - VkStructureType sType - void* pNext - VkDriverIdKHR driverID - char[VK_MAX_DRIVER_NAME_SIZE_KHR] driverName - char[VK_MAX_DRIVER_INFO_SIZE_KHR] driverInfo - VkConformanceVersionKHR conformanceVersion -} - -@extension("VK_KHR_shader_float_controls") // 198 -class VkPhysicalDeviceFloatControlsPropertiesKHR { - VkStructureType sType - void* pNext - VkBool32 separateDenormSettings - VkBool32 separateRoundingModeSettings - VkBool32 shaderSignedZeroInfNanPreserveFloat16 - VkBool32 shaderSignedZeroInfNanPreserveFloat32 - VkBool32 shaderSignedZeroInfNanPreserveFloat64 - VkBool32 shaderDenormPreserveFloat16 - VkBool32 shaderDenormPreserveFloat32 - VkBool32 shaderDenormPreserveFloat64 - VkBool32 shaderDenormFlushToZeroFloat16 - VkBool32 shaderDenormFlushToZeroFloat32 - VkBool32 shaderDenormFlushToZeroFloat64 - VkBool32 shaderRoundingModeRTEFloat16 - VkBool32 shaderRoundingModeRTEFloat32 - VkBool32 shaderRoundingModeRTEFloat64 - VkBool32 shaderRoundingModeRTZFloat16 - VkBool32 shaderRoundingModeRTZFloat32 - VkBool32 shaderRoundingModeRTZFloat64 -} - -@extension("VK_NV_compute_shader_derivatives") // 202 -class VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { - VkStructureType sType - void* pNext - VkBool32 computeDerivativeGroupQuads - VkBool32 computeDerivativeGroupLinear -} - -@extension("VK_NV_mesh_shader") // 203 -class VkPhysicalDeviceMeshShaderFeaturesNV { - VkStructureType sType - void* pNext - VkBool32 taskShader - VkBool32 meshShader -} - -@extension("VK_NV_mesh_shader") // 203 -class VkPhysicalDeviceMeshShaderPropertiesNV { - VkStructureType sType - void* pNext - u32 maxDrawMeshTasksCount - u32 maxTaskWorkGroupInvocations - u32[3] maxTaskWorkGroupSize - u32 maxTaskTotalMemorySize - u32 maxTaskOutputCount - u32 maxMeshWorkGroupInvocations - u32[3] maxMeshWorkGroupSize - u32 maxMeshTotalMemorySize - u32 maxMeshOutputVertices - u32 maxMeshOutputPrimitives - u32 maxMeshMultiviewViewCount - u32 meshOutputPerVertexGranularity - u32 meshOutputPerPrimitiveGranularity -} - -@extension("VK_NV_mesh_shader") // 203 -class VkDrawMeshTasksIndirectCommandNV { - u32 taskCount - u32 firstTask -} - -@extension("VK_NV_fragment_shader_barycentric") // 204 -class VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV { - VkStructureType sType - void* pNext - VkBool32 fragmentShaderBarycentric -} - -@extension("VK_NV_shader_image_footprint") // 205 -class VkPhysicalDeviceShaderImageFootprintFeaturesNV { - VkStructureType sType - void* pNext - VkBool32 imageFootprint -} - -@extension("VK_NV_scissor_exclusive") // 206 -class VkPipelineViewportExclusiveScissorStateCreateInfoNV { - VkStructureType sType - const void* pNext - u32 exclusiveScissorCount - const VkRect2D* pExclusiveScissors -} - -@extension("VK_NV_scissor_exclusive") // 206 -class VkPhysicalDeviceExclusiveScissorFeaturesNV { - VkStructureType sType - void* pNext - VkBool32 exclusiveScissor -} - -@extension("VK_NV_device_diagnostic_checkpoints") // 207 -class VkQueueFamilyCheckpointPropertiesNV { - VkStructureType sType - void* pNext - VkPipelineStageFlags checkpointExecutionStageMask -} - -@extension("VK_NV_device_diagnostic_checkpoints") // 207 -class VkCheckpointDataNV { - VkStructureType sType - void* pNext - VkPipelineStageFlagBits stage - void* pCheckpointMarker -} - -@extension("VK_KHR_vulkan_memory_model") // 212 -class VkPhysicalDeviceVulkanMemoryModelFeaturesKHR { - VkStructureType sType - void* pNext - VkBool32 vulkanMemoryModel - VkBool32 vulkanMemoryModelDeviceScope -} - -@extension("VK_EXT_pci_bus_info") // 213 -class VkPhysicalDevicePCIBusInfoPropertiesEXT { - VkStructureType sType - void* pNext - u32 pciDomain - u32 pciBus - u32 pciDevice - u32 pciFunction -} - -@extension("VK_FUCHSIA_imagepipe_surface") // 215 -class VkImagePipeSurfaceCreateInfoFUCHSIA { - VkStructureType sType - const void* pNext - VkImagePipeSurfaceCreateFlagsFUCHSIA flags - platform.zx_handle_t imagePipeHandle -} - -@extension("VK_EXT_fragment_density_map") // 219 -class VkPhysicalDeviceFragmentDensityMapFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 fragmentDensityMap - VkBool32 fragmentDensityMapDynamic - VkBool32 fragmentDensityMapNonSubsampledImages -} - -@extension("VK_EXT_fragment_density_map") // 219 -class VkPhysicalDeviceFragmentDensityMapPropertiesEXT { - VkStructureType sType - void* pNext - VkExtent2D minFragmentDensityTexelSize - VkExtent2D maxFragmentDensityTexelSize - VkBool32 fragmentDensityInvocations -} - -@extension("VK_EXT_fragment_density_map") // 219 -class VkRenderPassFragmentDensityMapCreateInfoEXT { - VkStructureType sType - const void* pNext - VkAttachmentReference fragmentDensityMapAttachment -} - -@extension("VK_EXT_scalar_block_layout") // 222 -class VkPhysicalDeviceScalarBlockLayoutFeaturesEXT { - VkStructureType sType - void* pNext - VkBool32 scalarBlockLayout -} - -@extension("VK_EXT_separate_stencil_usage") // 247 -class VkImageStencilUsageCreateInfoEXT { - VkStructureType sType - const void* pNext - VkImageUsageFlags stencilUsage -} - - -//////////////// -// Commands // -//////////////// - -// Function pointers. TODO: add support for function pointers. - -@external type void* PFN_vkVoidFunction -@pfn cmd void vkVoidFunction() { -} - -@external type void* PFN_vkAllocationFunction -@pfn cmd void* vkAllocationFunction( - void* pUserData, - platform.size_t size, - platform.size_t alignment, - VkSystemAllocationScope allocationScope) { - return ? -} - -@external type void* PFN_vkReallocationFunction -@pfn cmd void* vkReallocationFunction( - void* pUserData, - void* pOriginal, - platform.size_t size, - platform.size_t alignment, - VkSystemAllocationScope allocationScope) { - return ? -} - -@external type void* PFN_vkFreeFunction -@pfn cmd void vkFreeFunction( - void* pUserData, - void* pMemory) { -} - -@external type void* PFN_vkInternalAllocationNotification -@pfn cmd void vkInternalAllocationNotification( - void* pUserData, - platform.size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope) { -} - -@external type void* PFN_vkInternalFreeNotification -@pfn cmd void vkInternalFreeNotification( - void* pUserData, - platform.size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope) { -} - -// Global functions - -@threadSafety("system") -cmd VkResult vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) - - instance := ? - pInstance[0] = instance - State.Instances[instance] = new!InstanceObject() - - layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.enabledLayerCount] - extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.enabledExtensionCount] - - return ? -} - -@threadSafety("system") -cmd void vkDestroyInstance( - VkInstance instance, - const VkAllocationCallbacks* pAllocator) { - instanceObject := GetInstance(instance) - - State.Instances[instance] = null -} - -@threadSafety("system") -cmd VkResult vkEnumeratePhysicalDevices( - VkInstance instance, - u32* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices) { - instanceObject := GetInstance(instance) - - physicalDeviceCount := as!u32(?) - pPhysicalDeviceCount[0] = physicalDeviceCount - physicalDevices := pPhysicalDevices[0:physicalDeviceCount] - - for i in (0 .. physicalDeviceCount) { - physicalDevice := ? - physicalDevices[i] = physicalDevice - if !(physicalDevice in State.PhysicalDevices) { - State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance) - } - } - - return ? -} - -cmd PFN_vkVoidFunction vkGetDeviceProcAddr( - VkDevice device, - const char* pName) { - if device != NULL_HANDLE { - device := GetDevice(device) - } - - return ? -} - -cmd PFN_vkVoidFunction vkGetInstanceProcAddr( - VkInstance instance, - const char* pName) { - if instance != NULL_HANDLE { - instanceObject := GetInstance(instance) - } - - return ? -} - -cmd void vkGetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - properties := ? - pProperties[0] = properties -} - -cmd void vkGetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - u32* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - // TODO: Figure out how to express fetch-count-or-properties - // This version fails 'apic validate' with 'fence not allowed in - // *semantic.Branch'. Other attempts have failed with the same or other - // errors. - // if pQueueFamilyProperties != null { - // queuesProperties := pQueueFamilyProperties[0:pCount[0]] - // for i in (0 .. pCount[0]) { - // queueProperties := as!VkQueueFamilyProperties(?) - // queuesProperties[i] = queueProperties - // } - // } else { - // count := ? - // pCount[0] = count - // } -} - -cmd void vkGetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - memoryProperties := ? - pMemoryProperties[0] = memoryProperties -} - -cmd void vkGetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - features := ? - pFeatures[0] = features -} - -cmd void vkGetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - formatProperties := ? - pFormatProperties[0] = formatProperties -} - -cmd VkResult vkGetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties* pImageFormatProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - imageFormatProperties := ? - pImageFormatProperties[0] = imageFormatProperties - - return ? -} - - -// Device functions - -@threadSafety("system") -cmd VkResult vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO) - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - device := ? - pDevice[0] = device - State.Devices[device] = new!DeviceObject(physicalDevice: physicalDevice) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyDevice( - VkDevice device, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - - State.Devices[device] = null -} - - -// Extension discovery functions - -cmd VkResult vkEnumerateInstanceLayerProperties( - u32* pPropertyCount, - VkLayerProperties* pProperties) { - count := as!u32(?) - pPropertyCount[0] = count - - properties := pProperties[0:count] - for i in (0 .. count) { - property := ? - properties[i] = property - } - - return ? -} - -cmd VkResult vkEnumerateInstanceExtensionProperties( - const char* pLayerName, - u32* pPropertyCount, - VkExtensionProperties* pProperties) { - count := as!u32(?) - pPropertyCount[0] = count - - properties := pProperties[0:count] - for i in (0 .. count) { - property := ? - properties[i] = property - } - - return ? -} - -cmd VkResult vkEnumerateDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - u32* pPropertyCount, - VkLayerProperties* pProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - count := as!u32(?) - pPropertyCount[0] = count - - properties := pProperties[0:count] - for i in (0 .. count) { - property := ? - properties[i] = property - } - - return ? -} - -cmd VkResult vkEnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - u32* pPropertyCount, - VkExtensionProperties* pProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - count := as!u32(?) - pPropertyCount[0] = count - - properties := pProperties[0:count] - for i in (0 .. count) { - property := ? - properties[i] = property - } - - return ? -} - - -// Queue functions - -@threadSafety("system") -cmd void vkGetDeviceQueue( - VkDevice device, - u32 queueFamilyIndex, - u32 queueIndex, - VkQueue* pQueue) { - deviceObject := GetDevice(device) - - queue := ? - pQueue[0] = queue - - if !(queue in State.Queues) { - State.Queues[queue] = new!QueueObject(device: device) - } -} - -@threadSafety("app") -cmd VkResult vkQueueSubmit( - VkQueue queue, - u32 submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence) { - queueObject := GetQueue(queue) - - if fence != NULL_HANDLE { - fenceObject := GetFence(fence) - assert(fenceObject.device == queueObject.device) - } - - // commandBuffers := pcommandBuffers[0:commandBufferCount] - // for i in (0 .. commandBufferCount) { - // commandBuffer := commandBuffers[i] - // commandBufferObject := GetCommandBuffer(commandBuffer) - // assert(commandBufferObject.device == queueObject.device) - // - // validate("QueueCheck", commandBufferObject.queueFlags in queueObject.flags, - // "vkQueueSubmit: enqueued commandBuffer requires missing queue capabilities.") - // } - - return ? -} - -@threadSafety("system") -cmd VkResult vkQueueWaitIdle( - VkQueue queue) { - queueObject := GetQueue(queue) - - return ? -} - -@threadSafety("system") -cmd VkResult vkDeviceWaitIdle( - VkDevice device) { - deviceObject := GetDevice(device) - - return ? -} - - -// Memory functions - -@threadSafety("system") -cmd VkResult vkAllocateMemory( - VkDevice device, - const VkMemoryAllocateInfo* pAllocateInfo, - const VkAllocationCallbacks* pAllocator, - VkDeviceMemory* pMemory) { - assert(pAllocateInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO) - deviceObject := GetDevice(device) - - memory := ? - pMemory[0] = memory - State.DeviceMemories[memory] = new!DeviceMemoryObject( - device: device, - allocationSize: pAllocateInfo[0].allocationSize) - - return ? -} - -@threadSafety("system") -cmd void vkFreeMemory( - VkDevice device, - VkDeviceMemory memory, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - memoryObject := GetDeviceMemory(memory) - assert(memoryObject.device == device) - - // Check that no objects are still bound before freeing. - validate("MemoryCheck", len(memoryObject.boundObjects) == 0, - "vkFreeMemory: objects still bound") - validate("MemoryCheck", len(memoryObject.boundCommandBuffers) == 0, - "vkFreeMemory: commandBuffers still bound") - State.DeviceMemories[memory] = null -} - -@threadSafety("app") -cmd VkResult vkMapMemory( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData) { - deviceObject := GetDevice(device) - memoryObject := GetDeviceMemory(memory) - assert(memoryObject.device == device) - - assert(flags == as!VkMemoryMapFlags(0)) - assert((offset + size) <= memoryObject.allocationSize) - - return ? -} - -@threadSafety("app") -cmd void vkUnmapMemory( - VkDevice device, - VkDeviceMemory memory) { - deviceObject := GetDevice(device) - memoryObject := GetDeviceMemory(memory) - assert(memoryObject.device == device) -} - -cmd VkResult vkFlushMappedMemoryRanges( - VkDevice device, - u32 memoryRangeCount - const VkMappedMemoryRange* pMemoryRanges) { - deviceObject := GetDevice(device) - - memoryRanges := pMemoryRanges[0:memoryRangeCount] - for i in (0 .. memoryRangeCount) { - memoryRange := memoryRanges[i] - memoryObject := GetDeviceMemory(memoryRange.memory) - assert(memoryObject.device == device) - assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize) - } - - return ? -} - -cmd VkResult vkInvalidateMappedMemoryRanges( - VkDevice device, - u32 memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges) { - deviceObject := GetDevice(device) - - memoryRanges := pMemoryRanges[0:memoryRangeCount] - for i in (0 .. memoryRangeCount) { - memoryRange := memoryRanges[i] - memoryObject := GetDeviceMemory(memoryRange.memory) - assert(memoryObject.device == device) - assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize) - } - - return ? -} - - -// Memory management API functions - -cmd void vkGetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes) { - deviceObject := GetDevice(device) - - if memory != NULL_HANDLE { - memoryObject := GetDeviceMemory(memory) - assert(memoryObject.device == device) - } - - committedMemoryInBytes := ? - pCommittedMemoryInBytes[0] = committedMemoryInBytes -} - -cmd void vkGetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements) { - deviceObject := GetDevice(device) - bufferObject := GetBuffer(buffer) - assert(bufferObject.device == device) -} - -cmd VkResult vkBindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory memory, - VkDeviceSize memoryOffset) { - deviceObject := GetDevice(device) - bufferObject := GetBuffer(buffer) - assert(bufferObject.device == device) - - // Unbind buffer from previous memory object, if not VK_NULL_HANDLE. - if bufferObject.memory != NULL_HANDLE { - memoryObject := GetDeviceMemory(bufferObject.memory) - memoryObject.boundObjects[as!u64(buffer)] = null - } - - // Bind buffer to given memory object, if not VK_NULL_HANDLE. - if memory != NULL_HANDLE { - memoryObject := GetDeviceMemory(memory) - assert(memoryObject.device == device) - memoryObject.boundObjects[as!u64(buffer)] = memoryOffset - } - bufferObject.memory = memory - bufferObject.memoryOffset = memoryOffset - - return ? -} - -cmd void vkGetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements) { - deviceObject := GetDevice(device) - imageObject := GetImage(image) - assert(imageObject.device == device) -} - -cmd VkResult vkBindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory memory, - VkDeviceSize memoryOffset) { - deviceObject := GetDevice(device) - imageObject := GetImage(image) - assert(imageObject.device == device) - - // Unbind image from previous memory object, if not VK_NULL_HANDLE. - if imageObject.memory != NULL_HANDLE { - memoryObject := GetDeviceMemory(imageObject.memory) - memoryObject.boundObjects[as!u64(image)] = null - } - - // Bind image to given memory object, if not VK_NULL_HANDLE. - if memory != NULL_HANDLE { - memoryObject := GetDeviceMemory(memory) - assert(memoryObject.device == device) - memoryObject.boundObjects[as!u64(image)] = memoryOffset - } - imageObject.memory = memory - imageObject.memoryOffset = memoryOffset - - return ? -} - -cmd void vkGetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - u32* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { - deviceObject := GetDevice(device) - imageObject := GetImage(image) - assert(imageObject.device == device) -} - -cmd void vkGetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - u32* pPropertyCount, - VkSparseImageFormatProperties* pProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) -} - -cmd VkResult vkQueueBindSparse( - VkQueue queue, - u32 bindInfoCount, - const VkBindSparseInfo* pBindInfo, - VkFence fence) { - queueObject := GetQueue(queue) - - return ? -} - - -// Fence functions - -@threadSafety("system") -cmd VkResult vkCreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO) - deviceObject := GetDevice(device) - - fence := ? - pFence[0] = fence - State.Fences[fence] = new!FenceObject( - device: device, signaled: (pCreateInfo.flags == as!VkFenceCreateFlags(VK_FENCE_CREATE_SIGNALED_BIT))) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyFence( - VkDevice device, - VkFence fence, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - fenceObject := GetFence(fence) - assert(fenceObject.device == device) - - State.Fences[fence] = null -} - -@threadSafety("system") -cmd VkResult vkResetFences( - VkDevice device, - u32 fenceCount, - const VkFence* pFences) { - deviceObject := GetDevice(device) - - fences := pFences[0:fenceCount] - for i in (0 .. fenceCount) { - fence := fences[i] - fenceObject := GetFence(fence) - assert(fenceObject.device == device) - fenceObject.signaled = false - } - - return ? -} - -@threadSafety("system") -cmd VkResult vkGetFenceStatus( - VkDevice device, - VkFence fence) { - deviceObject := GetDevice(device) - fenceObject := GetFence(fence) - assert(fenceObject.device == device) - - return ? -} - -@threadSafety("system") -cmd VkResult vkWaitForFences( - VkDevice device, - u32 fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - u64 timeout) { /// timeout in nanoseconds - deviceObject := GetDevice(device) - - fences := pFences[0:fenceCount] - for i in (0 .. fenceCount) { - fence := fences[i] - fenceObject := GetFence(fence) - assert(fenceObject.device == device) - } - - return ? -} - - -// Queue semaphore functions - -@threadSafety("system") -cmd VkResult vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSemaphore* pSemaphore) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO) - deviceObject := GetDevice(device) - - semaphore := ? - pSemaphore[0] = semaphore - State.Semaphores[semaphore] = new!SemaphoreObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroySemaphore( - VkDevice device, - VkSemaphore semaphore, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - semaphoreObject := GetSemaphore(semaphore) - assert(semaphoreObject.device == device) - - State.Semaphores[semaphore] = null -} - - -// Event functions - -@threadSafety("system") -cmd VkResult vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO) - deviceObject := GetDevice(device) - - event := ? - pEvent[0] = event - State.Events[event] = new!EventObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - eventObject := GetEvent(event) - assert(eventObject.device == device) - - State.Events[event] = null -} - -@threadSafety("system") -cmd VkResult vkGetEventStatus( - VkDevice device, - VkEvent event) { - deviceObject := GetDevice(device) - eventObject := GetEvent(event) - assert(eventObject.device == device) - - return ? -} - -@threadSafety("system") -cmd VkResult vkSetEvent( - VkDevice device, - VkEvent event) { - deviceObject := GetDevice(device) - eventObject := GetEvent(event) - assert(eventObject.device == device) - - return ? -} - -@threadSafety("system") -cmd VkResult vkResetEvent( - VkDevice device, - VkEvent event) { - deviceObject := GetDevice(device) - eventObject := GetEvent(event) - assert(eventObject.device == device) - - return ? -} - - -// Query functions - -@threadSafety("system") -cmd VkResult vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkQueryPool* pQueryPool) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO) - deviceObject := GetDevice(device) - - queryPool := ? - pQueryPool[0] = queryPool - State.QueryPools[queryPool] = new!QueryPoolObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyQueryPool( - VkDevice device, - VkQueryPool queryPool, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - queryPoolObject := GetQueryPool(queryPool) - assert(queryPoolObject.device == device) - - State.QueryPools[queryPool] = null -} - -@threadSafety("system") -cmd VkResult vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - u32 firstQuery, - u32 queryCount, - platform.size_t dataSize, - void* pData, - VkDeviceSize stride, - VkQueryResultFlags flags) { - deviceObject := GetDevice(device) - queryPoolObject := GetQueryPool(queryPool) - assert(queryPoolObject.device == device) - - data := pData[0:dataSize] - - return ? -} - -// Buffer functions - -@threadSafety("system") -cmd VkResult vkCreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBuffer* pBuffer) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO) - deviceObject := GetDevice(device) - - buffer := ? - pBuffer[0] = buffer - State.Buffers[buffer] = new!BufferObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyBuffer( - VkDevice device, - VkBuffer buffer, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - bufferObject := GetBuffer(buffer) - assert(bufferObject.device == device) - - assert(bufferObject.memory == 0) - State.Buffers[buffer] = null -} - - -// Buffer view functions - -@threadSafety("system") -cmd VkResult vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferView* pView) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO) - deviceObject := GetDevice(device) - - bufferObject := GetBuffer(pCreateInfo.buffer) - assert(bufferObject.device == device) - - view := ? - pView[0] = view - State.BufferViews[view] = new!BufferViewObject(device: device, buffer: pCreateInfo.buffer) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyBufferView( - VkDevice device, - VkBufferView bufferView, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - bufferViewObject := GetBufferView(bufferView) - assert(bufferViewObject.device == device) - - State.BufferViews[bufferView] = null -} - - -// Image functions - -@threadSafety("system") -cmd VkResult vkCreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImage* pImage) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO) - deviceObject := GetDevice(device) - - image := ? - pImage[0] = image - State.Images[image] = new!ImageObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyImage( - VkDevice device, - VkImage image, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - imageObject := GetImage(image) - assert(imageObject.device == device) - - assert(imageObject.memory == 0) - State.Images[image] = null -} - -cmd void vkGetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout) { - deviceObject := GetDevice(device) - imageObject := GetImage(image) - assert(imageObject.device == device) -} - - -// Image view functions - -@threadSafety("system") -cmd VkResult vkCreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImageView* pView) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO) - deviceObject := GetDevice(device) - - imageObject := GetImage(pCreateInfo.image) - assert(imageObject.device == device) - - view := ? - pView[0] = view - State.ImageViews[view] = new!ImageViewObject(device: device, image: pCreateInfo.image) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyImageView( - VkDevice device, - VkImageView imageView, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - imageViewObject := GetImageView(imageView) - assert(imageViewObject.device == device) - - State.ImageViews[imageView] = null -} - - -// Shader functions - -cmd VkResult vkCreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkShaderModule* pShaderModule) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) - deviceObject := GetDevice(device) - - shaderModule := ? - pShaderModule[0] = shaderModule - State.ShaderModules[shaderModule] = new!ShaderModuleObject(device: device) - - return ? -} - -cmd void vkDestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - shaderModuleObject := GetShaderModule(shaderModule) - assert(shaderModuleObject.device == device) - - State.ShaderModules[shaderModule] = null -} - - -// Pipeline functions - -cmd VkResult vkCreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO) - deviceObject := GetDevice(device) - - pipelineCache := ? - pPipelineCache[0] = pipelineCache - State.PipelineCaches[pipelineCache] = new!PipelineCacheObject(device: device) - - return ? -} - -cmd void vkDestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - pipelineCacheObject := GetPipelineCache(pipelineCache) - assert(pipelineCacheObject.device == device) - - State.PipelineCaches[pipelineCache] = null -} - -cmd VkResult vkGetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - platform.size_t* pDataSize, - void* pData) { - deviceObject := GetDevice(device) - pipelineCacheObject := GetPipelineCache(pipelineCache) - assert(pipelineCacheObject.device == device) - - return ? -} - -cmd VkResult vkMergePipelineCaches( - VkDevice device, - VkPipelineCache dstCache, - u32 srcCacheCount, - const VkPipelineCache* pSrcCaches) { - deviceObject := GetDevice(device) - dstCacheObject := GetPipelineCache(dstCache) - assert(dstCacheObject.device == device) - - srcCaches := pSrcCaches[0:srcCacheCount] - for i in (0 .. srcCacheCount) { - srcCache := srcCaches[i] - srcCacheObject := GetPipelineCache(srcCache) - assert(srcCacheObject.device == device) - } - - return ? -} - -cmd VkResult vkCreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - u32 createInfoCount, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) { - deviceObject := GetDevice(device) - if pipelineCache != NULL_HANDLE { - pipelineCacheObject := GetPipelineCache(pipelineCache) - assert(pipelineCacheObject.device == device) - } - - createInfos := pCreateInfos[0:createInfoCount] - pipelines := pPipelines[0:createInfoCount] - for i in (0 .. createInfoCount) { - pipeline := ? - pipelines[i] = pipeline - State.Pipelines[pipeline] = new!PipelineObject(device: device) - } - - return ? -} - -cmd VkResult vkCreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - u32 createInfoCount, - const VkComputePipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) { - deviceObject := GetDevice(device) - if pipelineCache != NULL_HANDLE { - pipelineCacheObject := GetPipelineCache(pipelineCache) - assert(pipelineCacheObject.device == device) - } - - createInfos := pCreateInfos[0:createInfoCount] - pipelines := pPipelines[0:createInfoCount] - for i in (0 .. createInfoCount) { - pipeline := ? - pipelines[i] = pipeline - State.Pipelines[pipeline] = new!PipelineObject(device: device) - } - - return ? -} - -@threadSafety("system") -cmd void vkDestroyPipeline( - VkDevice device, - VkPipeline pipeline, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - pipelineObjects := GetPipeline(pipeline) - assert(pipelineObjects.device == device) - - State.Pipelines[pipeline] = null -} - - -// Pipeline layout functions - -@threadSafety("system") -cmd VkResult vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineLayout* pPipelineLayout) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO) - deviceObject := GetDevice(device) - - pipelineLayout := ? - pPipelineLayout[0] = pipelineLayout - State.PipelineLayouts[pipelineLayout] = new!PipelineLayoutObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - pipelineLayoutObjects := GetPipelineLayout(pipelineLayout) - assert(pipelineLayoutObjects.device == device) - - State.PipelineLayouts[pipelineLayout] = null -} - - -// Sampler functions - -@threadSafety("system") -cmd VkResult vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSampler* pSampler) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO) - deviceObject := GetDevice(device) - - sampler := ? - pSampler[0] = sampler - State.Samplers[sampler] = new!SamplerObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroySampler( - VkDevice device, - VkSampler sampler, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - samplerObject := GetSampler(sampler) - assert(samplerObject.device == device) - - State.Samplers[sampler] = null -} - - -// Descriptor set functions - -@threadSafety("system") -cmd VkResult vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorSetLayout* pSetLayout) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) - deviceObject := GetDevice(device) - - setLayout := ? - pSetLayout[0] = setLayout - State.DescriptorSetLayouts[setLayout] = new!DescriptorSetLayoutObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - descriptorSetLayoutObject := GetDescriptorSetLayout(descriptorSetLayout) - assert(descriptorSetLayoutObject.device == device) - - State.DescriptorSetLayouts[descriptorSetLayout] = null -} - -@threadSafety("system") -cmd VkResult vkCreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorPool* pDescriptorPool) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO) - deviceObject := GetDevice(device) - - descriptorPool := ? - pDescriptorPool[0] = descriptorPool - State.DescriptorPools[descriptorPool] = new!DescriptorPoolObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - descriptorPoolObject := GetDescriptorPool(descriptorPool) - assert(descriptorPoolObject.device == device) - - State.DescriptorPools[descriptorPool] = null -} - -@threadSafety("app") -cmd VkResult vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags) { - deviceObject := GetDevice(device) - descriptorPoolObject := GetDescriptorPool(descriptorPool) - assert(descriptorPoolObject.device == device) - - return ? -} - -@threadSafety("app") -cmd VkResult vkAllocateDescriptorSets( - VkDevice device, - const VkDescriptorSetAllocateInfo* pAllocateInfo, - VkDescriptorSet* pDescriptorSets) { - deviceObject := GetDevice(device) - allocInfo := pAllocateInfo[0] - descriptorPoolObject := GetDescriptorPool(allocInfo.descriptorPool) - - setLayouts := allocInfo.pSetLayouts[0:allocInfo.setCount] - for i in (0 .. allocInfo.setCount) { - setLayout := setLayouts[i] - setLayoutObject := GetDescriptorSetLayout(setLayout) - assert(setLayoutObject.device == device) - } - - descriptorSets := pDescriptorSets[0:allocInfo.setCount] - for i in (0 .. allocInfo.setCount) { - descriptorSet := ? - descriptorSets[i] = descriptorSet - State.DescriptorSets[descriptorSet] = new!DescriptorSetObject(device: device) - } - - return ? -} - -cmd VkResult vkFreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - u32 descriptorSetCount, - const VkDescriptorSet* pDescriptorSets) { - deviceObject := GetDevice(device) - descriptorPoolObject := GetDescriptorPool(descriptorPool) - - descriptorSets := pDescriptorSets[0:descriptorSetCount] - for i in (0 .. descriptorSetCount) { - descriptorSet := descriptorSets[i] - descriptorSetObject := GetDescriptorSet(descriptorSet) - assert(descriptorSetObject.device == device) - State.DescriptorSets[descriptorSet] = null - } - - return ? -} - -cmd void vkUpdateDescriptorSets( - VkDevice device, - u32 descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites, - u32 descriptorCopyCount, - const VkCopyDescriptorSet* pDescriptorCopies) { - deviceObject := GetDevice(device) - - descriptorWrites := pDescriptorWrites[0:descriptorWriteCount] - for i in (0 .. descriptorWriteCount) { - descriptorWrite := descriptorWrites[i] - descriptorWriteObject := GetDescriptorSet(descriptorWrite.dstSet) - assert(descriptorWriteObject.device == device) - } - - descriptorCopies := pDescriptorCopies[0:descriptorCopyCount] - for i in (0 .. descriptorCopyCount) { - descriptorCopy := descriptorCopies[i] - descriptorCopyObject := GetDescriptorSet(descriptorCopy.dstSet) - assert(descriptorCopyObject.device == device) - } -} - - -// Framebuffer functions - -@threadSafety("system") -cmd VkResult vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFramebuffer* pFramebuffer) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO) - deviceObject := GetDevice(device) - - framebuffer := ? - pFramebuffer[0] = framebuffer - State.Framebuffers[framebuffer] = new!FramebufferObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - framebufferObject := GetFramebuffer(framebuffer) - assert(framebufferObject.device == device) - - State.Framebuffers[framebuffer] = null -} - - -// Renderpass functions - -@threadSafety("system") -cmd VkResult vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO) - deviceObject := GetDevice(device) - - renderpass := ? - pRenderPass[0] = renderpass - State.RenderPasses[renderpass] = new!RenderPassObject(device: device) - - return ? -} - -@threadSafety("system") -cmd void vkDestroyRenderPass( - VkDevice device, - VkRenderPass renderPass, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - renderPassObject := GetRenderPass(renderPass) - assert(renderPassObject.device == device) - - State.RenderPasses[renderPass] = null -} - -cmd void vkGetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity) { - deviceObject := GetDevice(device) - renderPassObject := GetRenderPass(renderPass) - - granularity := ? - pGranularity[0] = granularity -} - -// Command pool functions - -cmd VkResult vkCreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO) - deviceObject := GetDevice(device) - - commandPool := ? - pCommandPool[0] = commandPool - State.CommandPools[commandPool] = new!CommandPoolObject(device: device) - - return ? -} - -cmd void vkDestroyCommandPool( - VkDevice device, - VkCommandPool commandPool, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - commandPoolObject := GetCommandPool(commandPool) - assert(commandPoolObject.device == device) - - State.CommandPools[commandPool] = null -} - -cmd VkResult vkResetCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolResetFlags flags) { - deviceObject := GetDevice(device) - commandPoolObject := GetCommandPool(commandPool) - assert(commandPoolObject.device == device) - - return ? -} - -// Command buffer functions - -macro void bindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) { - memoryObject := GetDeviceMemory(memory) - memoryObject.boundCommandBuffers[commandBuffer] = commandBuffer - - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.boundObjects[as!u64(obj)] = memory -} - -macro void unbindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) { - memoryObject := GetDeviceMemory(memory) - memoryObject.boundCommandBuffers[commandBuffer] = null - - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.boundObjects[as!u64(obj)] = null -} - -@threadSafety("system") -cmd VkResult vkAllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers) { - assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO) - - count := pAllocateInfo[0].commandBufferCount - commandBuffers := pCommandBuffers[0:count] - for i in (0 .. count) { - commandBuffer := ? - commandBuffers[i] = commandBuffer - State.CommandBuffers[commandBuffer] = new!CommandBufferObject(device: device) - } - - return ? -} - -@threadSafety("system") -cmd void vkFreeCommandBuffers( - VkDevice device, - VkCommandPool commandPool, - u32 commandBufferCount, - const VkCommandBuffer* pCommandBuffers) { - deviceObject := GetDevice(device) - - commandBuffers := pCommandBuffers[0:commandBufferCount] - for i in (0 .. commandBufferCount) { - commandBufferObject := GetCommandBuffer(commandBuffers[i]) - assert(commandBufferObject.device == device) - // TODO: iterate over boundObjects and clear memory bindings - State.CommandBuffers[commandBuffers[i]] = null - } -} - -@threadSafety("app") -cmd VkResult vkBeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo) { - assert(pBeginInfo.sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) - commandBufferObject := GetCommandBuffer(commandBuffer) - - // TODO: iterate over boundObjects and clear memory bindings - - return ? -} - -@threadSafety("app") -cmd VkResult vkEndCommandBuffer( - VkCommandBuffer commandBuffer) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - return ? -} - -@threadSafety("app") -cmd VkResult vkResetCommandBuffer( - VkCommandBuffer commandBuffer, - VkCommandBufferResetFlags flags) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - // TODO: iterate over boundObjects and clear memory bindings - - return ? -} - - -// Command buffer building functions - -@threadSafety("app") -cmd void vkCmdBindPipeline( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline) { - commandBufferObject := GetCommandBuffer(commandBuffer) - pipelineObject := GetPipeline(pipeline) - assert(commandBufferObject.device == pipelineObject.device) - - queue := switch (pipelineBindPoint) { - case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT - case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT - } - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue) -} - -@threadSafety("app") -cmd void vkCmdSetViewport( - VkCommandBuffer commandBuffer, - u32 firstViewport, - u32 viewportCount, - const VkViewport* pViewports) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetScissor( - VkCommandBuffer commandBuffer, - u32 firstScissor, - u32 scissorCount, - const VkRect2D* pScissors) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetLineWidth( - VkCommandBuffer commandBuffer, - f32 lineWidth) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetDepthBias( - VkCommandBuffer commandBuffer, - f32 depthBiasConstantFactor, - f32 depthBiasClamp, - f32 depthBiasSlopeFactor) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetBlendConstants( - VkCommandBuffer commandBuffer, - // TODO(jessehall): apic only supports 'const' on pointer types. Using - // an annotation as a quick hack to pass this to the template without - // having to modify the AST and semantic model. - @readonly f32[4] blendConstants) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetDepthBounds( - VkCommandBuffer commandBuffer, - f32 minDepthBounds, - f32 maxDepthBounds) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetStencilCompareMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - u32 compareMask) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetStencilWriteMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - u32 writeMask) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetStencilReference( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - u32 reference) { - commandBufferObject := GetCommandBuffer(commandBuffer) - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdBindDescriptorSets( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - u32 firstSet, - u32 descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - u32 dynamicOffsetCount, - const u32* pDynamicOffsets) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - descriptorSets := pDescriptorSets[0:descriptorSetCount] - for i in (0 .. descriptorSetCount) { - descriptorSet := descriptorSets[i] - descriptorSetObject := GetDescriptorSet(descriptorSet) - assert(commandBufferObject.device == descriptorSetObject.device) - } - - dynamicOffsets := pDynamicOffsets[0:dynamicOffsetCount] - for i in (0 .. dynamicOffsetCount) { - dynamicOffset := dynamicOffsets[i] - } - - queue := switch (pipelineBindPoint) { - case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT - case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT - } - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue) -} - -@threadSafety("app") -cmd void vkCmdBindIndexBuffer( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType) { - commandBufferObject := GetCommandBuffer(commandBuffer) - bufferObject := GetBuffer(buffer) - assert(commandBufferObject.device == bufferObject.device) - - bindCommandBuffer(commandBuffer, buffer, bufferObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdBindVertexBuffers( - VkCommandBuffer commandBuffer, - u32 firstBinding, - u32 bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - // TODO: check if not [firstBinding:firstBinding+bindingCount] - buffers := pBuffers[0:bindingCount] - offsets := pOffsets[0:bindingCount] - for i in (0 .. bindingCount) { - buffer := buffers[i] - offset := offsets[i] - bufferObject := GetBuffer(buffer) - assert(commandBufferObject.device == bufferObject.device) - - bindCommandBuffer(commandBuffer, buffer, bufferObject.memory) - } - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdDraw( - VkCommandBuffer commandBuffer, - u32 vertexCount, - u32 instanceCount, - u32 firstVertex, - u32 firstInstance) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdDrawIndexed( - VkCommandBuffer commandBuffer, - u32 indexCount, - u32 instanceCount, - u32 firstIndex, - s32 vertexOffset, - u32 firstInstance) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - u32 drawCount, - u32 stride) { - commandBufferObject := GetCommandBuffer(commandBuffer) - bufferObject := GetBuffer(buffer) - assert(commandBufferObject.device == bufferObject.device) - - bindCommandBuffer(commandBuffer, buffer, bufferObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - u32 drawCount, - u32 stride) { - commandBufferObject := GetCommandBuffer(commandBuffer) - bufferObject := GetBuffer(buffer) - assert(commandBufferObject.device == bufferObject.device) - - bindCommandBuffer(commandBuffer, buffer, bufferObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdDispatch( - VkCommandBuffer commandBuffer, - u32 groupCountX, - u32 groupCountY, - u32 groupCountZ) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT) -} - -@threadSafety("app") -cmd void vkCmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset) { - commandBufferObject := GetCommandBuffer(commandBuffer) - bufferObject := GetBuffer(buffer) - assert(commandBufferObject.device == bufferObject.device) - - bindCommandBuffer(commandBuffer, buffer, bufferObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT) -} - -@threadSafety("app") -cmd void vkCmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - u32 regionCount, - const VkBufferCopy* pRegions) { - commandBufferObject := GetCommandBuffer(commandBuffer) - srcBufferObject := GetBuffer(srcBuffer) - dstBufferObject := GetBuffer(dstBuffer) - assert(commandBufferObject.device == srcBufferObject.device) - assert(commandBufferObject.device == dstBufferObject.device) - - regions := pRegions[0:regionCount] - for i in (0 .. regionCount) { - region := regions[i] - } - - bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory) - bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT) -} - -@threadSafety("app") -cmd void vkCmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - u32 regionCount, - const VkImageCopy* pRegions) { - commandBufferObject := GetCommandBuffer(commandBuffer) - srcImageObject := GetImage(srcImage) - dstImageObject := GetImage(dstImage) - assert(commandBufferObject.device == srcImageObject.device) - assert(commandBufferObject.device == dstImageObject.device) - - regions := pRegions[0:regionCount] - for i in (0 .. regionCount) { - region := regions[i] - } - - bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory) - bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT) -} - -@threadSafety("app") -cmd void vkCmdBlitImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - u32 regionCount, - const VkImageBlit* pRegions, - VkFilter filter) { - commandBufferObject := GetCommandBuffer(commandBuffer) - srcImageObject := GetImage(srcImage) - dstImageObject := GetImage(dstImage) - assert(commandBufferObject.device == srcImageObject.device) - assert(commandBufferObject.device == dstImageObject.device) - - regions := pRegions[0:regionCount] - for i in (0 .. regionCount) { - region := regions[i] - } - - bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory) - bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - u32 regionCount, - const VkBufferImageCopy* pRegions) { - commandBufferObject := GetCommandBuffer(commandBuffer) - srcBufferObject := GetBuffer(srcBuffer) - dstImageObject := GetImage(dstImage) - assert(commandBufferObject.device == srcBufferObject.device) - assert(commandBufferObject.device == dstImageObject.device) - - regions := pRegions[0:regionCount] - for i in (0 .. regionCount) { - region := regions[i] - } - - bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory) - bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT) -} - -@threadSafety("app") -cmd void vkCmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - u32 regionCount, - const VkBufferImageCopy* pRegions) { - commandBufferObject := GetCommandBuffer(commandBuffer) - srcImageObject := GetImage(srcImage) - dstBufferObject := GetBuffer(dstBuffer) - assert(commandBufferObject.device == srcImageObject.device) - assert(commandBufferObject.device == dstBufferObject.device) - - regions := pRegions[0:regionCount] - for i in (0 .. regionCount) { - region := regions[i] - } - - bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory) - bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT) -} - -@threadSafety("app") -cmd void vkCmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData) { - commandBufferObject := GetCommandBuffer(commandBuffer) - dstBufferObject := GetBuffer(dstBuffer) - assert(commandBufferObject.device == dstBufferObject.device) - - data := pData[0:dataSize] - - bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT) -} - -@threadSafety("app") -cmd void vkCmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - u32 data) { - commandBufferObject := GetCommandBuffer(commandBuffer) - dstBufferObject := GetBuffer(dstBuffer) - assert(commandBufferObject.device == dstBufferObject.device) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT) -} - -@threadSafety("app") -cmd void vkCmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - u32 rangeCount, - const VkImageSubresourceRange* pRanges) { - commandBufferObject := GetCommandBuffer(commandBuffer) - imageObject := GetImage(image) - assert(commandBufferObject.device == imageObject.device) - - ranges := pRanges[0:rangeCount] - for i in (0 .. rangeCount) { - range := ranges[i] - } - - bindCommandBuffer(commandBuffer, image, imageObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdClearDepthStencilImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - u32 rangeCount, - const VkImageSubresourceRange* pRanges) { - commandBufferObject := GetCommandBuffer(commandBuffer) - imageObject := GetImage(image) - assert(commandBufferObject.device == imageObject.device) - - ranges := pRanges[0:rangeCount] - for i in (0 .. rangeCount) { - range := ranges[i] - } - - bindCommandBuffer(commandBuffer, image, imageObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdClearAttachments( - VkCommandBuffer commandBuffer, - u32 attachmentCount, - const VkClearAttachment* pAttachments, - u32 rectCount, - const VkClearRect* pRects) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - rects := pRects[0:rectCount] - for i in (0 .. rectCount) { - rect := rects[i] - } - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdResolveImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - u32 regionCount, - const VkImageResolve* pRegions) { - commandBufferObject := GetCommandBuffer(commandBuffer) - srcImageObject := GetImage(srcImage) - dstImageObject := GetImage(dstImage) - assert(commandBufferObject.device == srcImageObject.device) - assert(commandBufferObject.device == dstImageObject.device) - - regions := pRegions[0:regionCount] - for i in (0 .. regionCount) { - region := regions[i] - } - - bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory) - bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -@threadSafety("app") -cmd void vkCmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask) { - commandBufferObject := GetCommandBuffer(commandBuffer) - eventObject := GetEvent(event) - assert(commandBufferObject.device == eventObject.device) -} - -@threadSafety("app") -cmd void vkCmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask) { - commandBufferObject := GetCommandBuffer(commandBuffer) - eventObject := GetEvent(event) - assert(commandBufferObject.device == eventObject.device) -} - -@threadSafety("app") -cmd void vkCmdWaitEvents( - VkCommandBuffer commandBuffer, - u32 eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - u32 memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - u32 bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - u32 imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - events := pEvents[0:eventCount] - for i in (0 .. eventCount) { - event := events[i] - eventObject := GetEvent(event) - assert(commandBufferObject.device == eventObject.device) - } - - memoryBarriers := pMemoryBarriers[0:memoryBarrierCount] - for i in (0 .. memoryBarrierCount) { - memoryBarrier := memoryBarriers[i] - } - bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount] - for i in (0 .. bufferMemoryBarrierCount) { - bufferMemoryBarrier := bufferMemoryBarriers[i] - bufferObject := GetBuffer(bufferMemoryBarrier.buffer) - assert(bufferObject.device == commandBufferObject.device) - } - imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount] - for i in (0 .. imageMemoryBarrierCount) { - imageMemoryBarrier := imageMemoryBarriers[i] - imageObject := GetImage(imageMemoryBarrier.image) - assert(imageObject.device == commandBufferObject.device) - } -} - -@threadSafety("app") -cmd void vkCmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - u32 memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - u32 bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - u32 imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - memoryBarriers := pMemoryBarriers[0:memoryBarrierCount] - for i in (0 .. memoryBarrierCount) { - memoryBarrier := memoryBarriers[i] - } - bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount] - for i in (0 .. bufferMemoryBarrierCount) { - bufferMemoryBarrier := bufferMemoryBarriers[i] - bufferObject := GetBuffer(bufferMemoryBarrier.buffer) - assert(bufferObject.device == commandBufferObject.device) - } - imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount] - for i in (0 .. imageMemoryBarrierCount) { - imageMemoryBarrier := imageMemoryBarriers[i] - imageObject := GetImage(imageMemoryBarrier.image) - assert(imageObject.device == commandBufferObject.device) - } -} - -@threadSafety("app") -cmd void vkCmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - u32 query, - VkQueryControlFlags flags) { - commandBufferObject := GetCommandBuffer(commandBuffer) - queryPoolObject := GetQueryPool(queryPool) - assert(commandBufferObject.device == queryPoolObject.device) -} - -@threadSafety("app") -cmd void vkCmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - u32 query) { - commandBufferObject := GetCommandBuffer(commandBuffer) - queryPoolObject := GetQueryPool(queryPool) - assert(commandBufferObject.device == queryPoolObject.device) -} - -@threadSafety("app") -cmd void vkCmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - u32 firstQuery, - u32 queryCount) { - commandBufferObject := GetCommandBuffer(commandBuffer) - queryPoolObject := GetQueryPool(queryPool) - assert(commandBufferObject.device == queryPoolObject.device) -} - -@threadSafety("app") -cmd void vkCmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - u32 query) { - commandBufferObject := GetCommandBuffer(commandBuffer) - queryPoolObject := GetQueryPool(queryPool) - assert(commandBufferObject.device == queryPoolObject.device) -} - -@threadSafety("app") -cmd void vkCmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - u32 firstQuery, - u32 queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags) { - commandBufferObject := GetCommandBuffer(commandBuffer) - queryPoolObject := GetQueryPool(queryPool) - dstBufferObject := GetBuffer(dstBuffer) - assert(commandBufferObject.device == queryPoolObject.device) - assert(commandBufferObject.device == dstBufferObject.device) -} - -cmd void vkCmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - u32 offset, - u32 size, - const void* pValues) { - commandBufferObject := GetCommandBuffer(commandBuffer) - layoutObject := GetPipelineLayout(layout) - assert(commandBufferObject.device == layoutObject.device) -} - -@threadSafety("app") -cmd void vkCmdBeginRenderPass( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkSubpassContents contents) { - commandBufferObject := GetCommandBuffer(commandBuffer) - renderPassObject := GetRenderPass(pRenderPassBegin.renderPass) - framebufferObject := GetFramebuffer(pRenderPassBegin.framebuffer) - assert(commandBufferObject.device == renderPassObject.device) - assert(commandBufferObject.device == framebufferObject.device) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -cmd void vkCmdNextSubpass( - VkCommandBuffer commandBuffer, - VkSubpassContents contents) { - commandBufferObject := GetCommandBuffer(commandBuffer) -} - -@threadSafety("app") -cmd void vkCmdEndRenderPass( - VkCommandBuffer commandBuffer) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT) -} - -cmd void vkCmdExecuteCommands( - VkCommandBuffer commandBuffer, - u32 commandBufferCount, - const VkCommandBuffer* pCommandBuffers) { - commandBufferObject := GetCommandBuffer(commandBuffer) - - commandBuffers := pCommandBuffers[0:commandBufferCount] - for i in (0 .. commandBufferCount) { - secondaryCommandBuffer := commandBuffers[i] - secondaryCommandBufferObject := GetCommandBuffer(secondaryCommandBuffer) - assert(commandBufferObject.device == secondaryCommandBufferObject.device) - } -} - -//@vulkan1_1 functions - -@vulkan1_1 -cmd VkResult vkEnumerateInstanceVersion( - u32* pApiVersion) { - return ? -} - -@vulkan1_1 -cmd VkResult vkBindBufferMemory2( - VkDevice device, - u32 bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos) { - return ? -} - -@vulkan1_1 -cmd VkResult vkBindImageMemory2( - VkDevice device, - u32 bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos) { - return ? -} - -@vulkan1_1 -cmd void vkGetDeviceGroupPeerMemoryFeatures( - VkDevice device, - u32 heapIndex, - u32 localDeviceIndex, - u32 remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { -} - -@vulkan1_1 -cmd void vkCmdSetDeviceMask( - VkCommandBuffer commandBuffer, - u32 deviceMask) { -} - -@vulkan1_1 -cmd void vkCmdDispatchBase( - VkCommandBuffer commandBuffer, - u32 baseGroupX, - u32 baseGroupY, - u32 baseGroupZ, - u32 groupCountX, - u32 groupCountY, - u32 groupCountZ) { -} - -@threadSafety("system") -@vulkan1_1 -cmd VkResult vkEnumeratePhysicalDeviceGroups( - VkInstance instance, - u32* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { - instanceObject := GetInstance(instance) - - physicalDeviceGroupCount := as!u32(?) - pPhysicalDeviceGroupCount[0] = physicalDeviceGroupCount - physicalDevices := pPhysicalDeviceGroupProperties[0:physicalDeviceGroupCount] - - for i in (0 .. physicalDeviceGroupCount) { - physicalDevice := ? - physicalDevices[i] = physicalDevice - if !(physicalDevice in State.PhysicalDevices) { - State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance) - } - } - - return ? -} - -@vulkan1_1 -cmd void vkGetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) { -} - -@vulkan1_1 -cmd void vkGetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) { -} - -@vulkan1_1 -cmd void vkGetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - u32* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceFeatures2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures) { -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties) { -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceFormatProperties2( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties) { -} - -@vulkan1_1 -cmd VkResult vkGetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties) { - return ? -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, - u32* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties) { -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - u32* pPropertyCount, - VkSparseImageFormatProperties2* pProperties) { -} - -@vulkan1_1 -cmd void vkTrimCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags) { -} - - -@vulkan1_1 -cmd void vkGetDeviceQueue2( - VkDevice device, - const VkDeviceQueueInfo2* pQueueInfo, - VkQueue* pQueue) { - deviceObject := GetDevice(device) - - queue := ? - pQueue[0] = queue - - if !(queue in State.Queues) { - State.Queues[queue] = new!QueueObject(device: device) - } -} - -@vulkan1_1 -cmd VkResult vkCreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion) { - return ? -} - -@vulkan1_1 -cmd void vkDestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator) { -} - -@vulkan1_1 -cmd VkResult vkCreateDescriptorUpdateTemplate( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { - return ? -} - -@vulkan1_1 -cmd void vkDestroyDescriptorUpdateTemplate( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator) { -} - -@vulkan1_1 -cmd void vkUpdateDescriptorSetWithTemplate( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData) { -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties) { -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties) { -} - -@vulkan1_1 -cmd void vkGetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { -} - -@vulkan1_1 -cmd void vkGetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport) { -} - - -@extension("VK_KHR_surface") // 1 -cmd void vkDestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator) { - instanceObject := GetInstance(instance) - surfaceObject := GetSurface(surface) - assert(surfaceObject.instance == instance) - - State.Surfaces[surface] = null -} - -@extension("VK_KHR_surface") // 1 -cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - u32 queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - return ? -} - -@extension("VK_KHR_surface") // 1 -cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - surfaceCapabilities := ? - pSurfaceCapabilities[0] = surfaceCapabilities - - return ? -} - -@extension("VK_KHR_surface") // 1 -cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - u32* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - count := as!u32(?) - pSurfaceFormatCount[0] = count - surfaceFormats := pSurfaceFormats[0:count] - - for i in (0 .. count) { - surfaceFormat := ? - surfaceFormats[i] = surfaceFormat - } - - return ? -} - -@extension("VK_KHR_surface") // 1 -cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - u32* pPresentModeCount, - VkPresentModeKHR* pPresentModes) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - - count := as!u32(?) - pPresentModeCount[0] = count - presentModes := pPresentModes[0:count] - - for i in (0 .. count) { - presentMode := ? - presentModes[i] = presentMode - } - - return ? -} - -@extension("VK_KHR_swapchain") // 2 -cmd VkResult vkCreateSwapchainKHR( - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchain) { - assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR) - deviceObject := GetDevice(device) - - swapchain := ? - pSwapchain[0] = swapchain - State.Swapchains[swapchain] = new!SwapchainObject(device: device) - - return ? -} - -@extension("VK_KHR_swapchain") // 2 -cmd void vkDestroySwapchainKHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkAllocationCallbacks* pAllocator) { - deviceObject := GetDevice(device) - swapchainObject := GetSwapchain(swapchain) - assert(swapchainObject.device == device) - - State.Swapchains[swapchain] = null -} - -@extension("VK_KHR_swapchain") // 2 -cmd VkResult vkGetSwapchainImagesKHR( - VkDevice device, - VkSwapchainKHR swapchain, - u32* pSwapchainImageCount, - VkImage* pSwapchainImages) { - deviceObject := GetDevice(device) - - count := as!u32(?) - pSwapchainImageCount[0] = count - swapchainImages := pSwapchainImages[0:count] - - for i in (0 .. count) { - swapchainImage := ? - swapchainImages[i] = swapchainImage - State.Images[swapchainImage] = new!ImageObject(device: device) - } - - return ? -} - -@extension("VK_KHR_swapchain") // 2 -cmd VkResult vkAcquireNextImageKHR( - VkDevice device, - VkSwapchainKHR swapchain, - u64 timeout, - VkSemaphore semaphore, - VkFence fence, - u32* pImageIndex) { - deviceObject := GetDevice(device) - swapchainObject := GetSwapchain(swapchain) - - imageIndex := ? - pImageIndex[0] = imageIndex - - return ? -} - -@extension("VK_KHR_swapchain") // 2 -cmd VkResult vkQueuePresentKHR( - VkQueue queue, - const VkPresentInfoKHR* pPresentInfo) { - queueObject := GetQueue(queue) - - presentInfo := ? - pPresentInfo[0] = presentInfo - - return ? -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -cmd VkResult vkGetDeviceGroupPresentCapabilitiesKHR( - VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { - return ? -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -cmd VkResult vkGetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes) { - return ? -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -cmd VkResult vkGetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - u32* pRectCount, - VkRect2D* pRects) { - return ? -} - -@vulkan1_1 -@extension("VK_KHR_swapchain") // 2 -cmd VkResult vkAcquireNextImage2KHR( - VkDevice device, - const VkAcquireNextImageInfoKHR* pAcquireInfo, - u32* pImageIndex) { - return ? -} - -@extension("VK_KHR_display") // 3 -cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( - VkPhysicalDevice physicalDevice, - u32* pPropertyCount, - VkDisplayPropertiesKHR* pProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_display") // 3 -cmd VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - VkPhysicalDevice physicalDevice, - u32* pPropertyCount, - VkDisplayPlanePropertiesKHR* pProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_display") // 3 -cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR( - VkPhysicalDevice physicalDevice, - u32 planeIndex, - u32* pDisplayCount, - VkDisplayKHR* pDisplays) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_display") // 3 -cmd VkResult vkGetDisplayModePropertiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - u32* pPropertyCount, - VkDisplayModePropertiesKHR* pProperties) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_display") // 3 -cmd VkResult vkCreateDisplayModeKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDisplayModeKHR* pMode) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_display") // 3 -cmd VkResult vkGetDisplayPlaneCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, - u32 planeIndex, - VkDisplayPlaneCapabilitiesKHR* pCapabilities) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_display") // 3 -cmd VkResult vkCreateDisplayPlaneSurfaceKHR( - VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - return ? -} - -@extension("VK_KHR_display_swapchain") // 4 -cmd VkResult vkCreateSharedSwapchainsKHR( - VkDevice device, - u32 swapchainCount, - const VkSwapchainCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchains) { - return ? -} - -@extension("VK_KHR_xlib_surface") // 5 -cmd VkResult vkCreateXlibSurfaceKHR( - VkInstance instance, - const VkXlibSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - instanceObject := GetInstance(instance) - return ? -} - -@extension("VK_KHR_xlib_surface") // 5 -cmd VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - u32 queueFamilyIndex, - platform.Display* dpy, - platform.VisualID visualID) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_xcb_surface") // 6 -cmd VkResult vkCreateXcbSurfaceKHR( - VkInstance instance, - const VkXcbSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - instanceObject := GetInstance(instance) - return ? -} - -@extension("VK_KHR_xcb_surface") // 6 -cmd VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - u32 queueFamilyIndex, - platform.xcb_connection_t* connection, - platform.xcb_visualid_t visual_id) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_wayland_surface") // 7 -cmd VkResult vkCreateWaylandSurfaceKHR( - VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - instanceObject := GetInstance(instance) - return ? -} - -@extension("VK_KHR_wayland_surface") // 7 -cmd VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - u32 queueFamilyIndex, - platform.wl_display* display) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_KHR_android_surface") // 9 -cmd VkResult vkCreateAndroidSurfaceKHR( - VkInstance instance, - const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - instanceObject := GetInstance(instance) - return ? -} - -@extension("VK_KHR_win32_surface") // 10 -cmd VkResult vkCreateWin32SurfaceKHR( - VkInstance instance, - const VkWin32SurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - instanceObject := GetInstance(instance) - return ? -} - -@extension("VK_KHR_win32_surface") // 10 -cmd VkResult vkGetPhysicalDeviceWin32PresentationSupportKHR( - VkPhysicalDevice physicalDevice, - u32 queueFamilyIndex) { - physicalDeviceObject := GetPhysicalDevice(physicalDevice) - return ? -} - -@extension("VK_ANDROID_native_buffer") // 11 -@optional -cmd VkResult vkGetSwapchainGrallocUsageANDROID( - VkDevice device, - VkFormat format, - VkImageUsageFlags imageUsage, - s32* grallocUsage) { - return ? -} - -@extension("VK_ANDROID_native_buffer") // 11 -@optional -cmd VkResult vkGetSwapchainGrallocUsage2ANDROID( - VkDevice device, - VkFormat format, - VkImageUsageFlags imageUsage, - VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, - u64* grallocConsumerUsage, - u64* grallocProducerUsage) { - return ? -} - -@extension("VK_ANDROID_native_buffer") // 11 -cmd VkResult vkAcquireImageANDROID( - VkDevice device, - VkImage image, - int nativeFenceFd, - VkSemaphore semaphore, - VkFence fence) { - return ? -} - -@extension("VK_ANDROID_native_buffer") // 11 -cmd VkResult vkQueueSignalReleaseImageANDROID( - VkQueue queue, - u32 waitSemaphoreCount, - const VkSemaphore* pWaitSemaphores, - VkImage image, - int* pNativeFenceFd) { - return ? -} - -@extension("VK_EXT_debug_report") // 12 -@external type void* PFN_vkDebugReportCallbackEXT -@extension("VK_EXT_debug_report") // 12 -@pfn cmd VkBool32 vkDebugReportCallbackEXT( - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - u64 object, - platform.size_t location, - s32 messageCode, - const char* pLayerPrefix, - const char* pMessage, - void* pUserData) { - return ? -} - -@extension("VK_EXT_debug_report") // 12 -cmd VkResult vkCreateDebugReportCallbackEXT( - VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugReportCallbackEXT* pCallback) { - return ? -} - -@extension("VK_EXT_debug_report") // 12 -cmd void vkDestroyDebugReportCallbackEXT( - VkInstance instance, - VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks* pAllocator) { -} - -@extension("VK_EXT_debug_report") // 12 -cmd void vkDebugReportMessageEXT( - VkInstance instance, - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - u64 object, - platform.size_t location, - s32 messageCode, - const char* pLayerPrefix, - const char* pMessage) { -} - -@extension("VK_EXT_debug_marker") // 23 -cmd VkResult vkDebugMarkerSetObjectTagEXT( - VkDevice device, - const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { - return ? -} - -@extension("VK_EXT_debug_marker") // 23 -cmd VkResult vkDebugMarkerSetObjectNameEXT( - VkDevice device, - const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { - return ? -} - -@extension("VK_EXT_debug_marker") // 23 -cmd void vkCmdDebugMarkerBeginEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { -} - -@extension("VK_EXT_debug_marker") // 23 -cmd void vkCmdDebugMarkerEndEXT( - VkCommandBuffer commandBuffer) { -} - -@extension("VK_EXT_debug_marker") // 23 -cmd void vkCmdDebugMarkerInsertEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { -} - -@extension("VK_EXT_transform_feedback") // 29 -cmd void vkCmdBindTransformFeedbackBuffersEXT( - VkCommandBuffer commandBuffer, - u32 firstBinding, - u32 bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes) { -} - -@extension("VK_EXT_transform_feedback") // 29 -cmd void vkCmdBeginTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - u32 firstCounterBuffer, - u32 counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets) { -} - -@extension("VK_EXT_transform_feedback") // 29 -cmd void vkCmdEndTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - u32 firstCounterBuffer, - u32 counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets) { -} - -@extension("VK_EXT_transform_feedback") // 29 -cmd void vkCmdBeginQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - u32 query, - VkQueryControlFlags flags, - u32 index) { -} - -@extension("VK_EXT_transform_feedback") // 29 -cmd void vkCmdEndQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - u32 query, - u32 index) { -} - -@extension("VK_EXT_transform_feedback") // 29 -cmd void vkCmdDrawIndirectByteCountEXT( - VkCommandBuffer commandBuffer, - u32 instanceCount, - u32 firstInstance, - VkBuffer counterBuffer, - VkDeviceSize counterBufferOffset, - u32 counterOffset, - u32 vertexStride) { -} - -@extension("VK_AMD_draw_indirect_count") // 34 -cmd void vkCmdDrawIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - u32 maxDrawCount, - u32 stride) { -} - -@extension("VK_AMD_draw_indirect_count") // 34 -cmd void vkCmdDrawIndexedIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - u32 maxDrawCount, - u32 stride) { -} - -@extension("VK_AMD_shader_info") // 43 -cmd VkResult vkGetShaderInfoAMD( - VkDevice device, - VkPipeline pipeline, - VkShaderStageFlagBits shaderStage, - VkShaderInfoTypeAMD infoType, - platform.size_t* pInfoSize, - void* pInfo) { - return ? -} - -@extension("VK_NV_external_memory_capabilities") // 56 -cmd VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { - return ? -} - -@extension("VK_NV_external_memory_win32") // 58 -cmd VkResult vkGetMemoryWin32HandleNV( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagsNV handleType, - platform.HANDLE* pHandle) { - return ? -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -cmd void vkGetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2KHR* pFeatures) { -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -cmd void vkGetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2KHR* pProperties) { -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -cmd void vkGetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2KHR* pFormatProperties) { -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -cmd VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, - VkImageFormatProperties2KHR* pImageFormatProperties) { - return ? -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -cmd void vkGetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - u32* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2KHR* pQueueFamilyProperties) { -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -cmd void vkGetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) { -} - -@extension("VK_KHR_get_physical_device_properties2") // 60 -cmd void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, - u32* pPropertyCount, - VkSparseImageFormatProperties2KHR* pProperties) { -} - -@extension("VK_KHR_device_group") // 61 -cmd void vkGetDeviceGroupPeerMemoryFeaturesKHR( - VkDevice device, - u32 heapIndex, - u32 localDeviceIndex, - u32 remoteDeviceIndex, - VkPeerMemoryFeatureFlagsKHR* pPeerMemoryFeatures) { -} - -@extension("VK_KHR_device_group") // 61 -cmd void vkCmdSetDeviceMaskKHR( - VkCommandBuffer commandBuffer, - u32 deviceMask) { -} - - -@extension("VK_KHR_device_group") // 61 -cmd void vkCmdDispatchBaseKHR( - VkCommandBuffer commandBuffer, - u32 baseGroupX, - u32 baseGroupY, - u32 baseGroupZ, - u32 groupCountX, - u32 groupCountY, - u32 groupCountZ) { -} - -@extension("VK_NN_vi_surface") // 63 -cmd VkResult vkCreateViSurfaceNN( - VkInstance instance, - const VkViSurfaceCreateInfoNN* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - return ? -} - -@extension("VK_KHR_maintenance1") // 70 -cmd void vkTrimCommandPoolKHR( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlagsKHR flags) { -} - -@extension("VK_KHR_device_group_creation") // 71 -@threadSafety("system") -cmd VkResult vkEnumeratePhysicalDeviceGroupsKHR( - VkInstance instance, - u32* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties) { - instanceObject := GetInstance(instance) - - physicalDeviceGroupCount := as!u32(?) - pPhysicalDeviceGroupCount[0] = physicalDeviceGroupCount - physicalDevices := pPhysicalDeviceGroupProperties[0:physicalDeviceGroupCount] - - for i in (0 .. physicalDeviceGroupCount) { - physicalDevice := ? - physicalDevices[i] = physicalDevice - if !(physicalDevice in State.PhysicalDevices) { - State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance) - } - } - - return ? -} - -@extension("VK_KHR_external_memory_capabilities") // 72 -cmd void vkGetPhysicalDeviceExternalBufferPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, - VkExternalBufferPropertiesKHR* pExternalBufferProperties) { -} - -@extension("VK_KHR_external_memory_win32") // 74 -cmd VkResult vkGetMemoryWin32HandleKHR( - VkDevice device, - const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, - platform.HANDLE* pHandle) { - return ? -} - -@extension("VK_KHR_external_memory_win32") // 74 -cmd VkResult vkGetMemoryWin32HandlePropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBitsKHR handleType, - platform.HANDLE handle, - VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { - return ? -} - -@extension("VK_KHR_external_memory_fd") // 75 -cmd VkResult vkGetMemoryFdKHR( - VkDevice device, - const VkMemoryGetFdInfoKHR* pGetFdInfo, - s32* pFd) { - return ? -} - -@extension("VK_KHR_external_memory_fd") // 75 -cmd VkResult vkGetMemoryFdPropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBitsKHR handleType, - s32 fd, - VkMemoryFdPropertiesKHR* pMemoryFdProperties) { - return ? -} - -@extension("VK_KHR_external_semaphore_capabilities") // 77 -cmd void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, - VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties) { -} - -@extension("VK_KHR_external_semaphore_win32") // 79 -cmd VkResult vkImportSemaphoreWin32HandleKHR( - VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { - return ? -} - -@extension("VK_KHR_external_semaphore_win32") // 79 -cmd VkResult vkGetSemaphoreWin32HandleKHR( - VkDevice device, - const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, - platform.HANDLE* pHandle) { - return ? -} - -@extension("VK_KHR_external_semaphore_fd") // 80 -cmd VkResult vkImportSemaphoreFdKHR( - VkDevice device, - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { - return ? -} - -@extension("VK_KHR_external_semaphore_fd") // 80 -cmd VkResult vkGetSemaphoreFdKHR( - VkDevice device, - const VkSemaphoreGetFdInfoKHR* pGetFdInfo, - s32* pFd) { - return ? -} - -@extension("VK_KHR_push_descriptor") // 81 -cmd void vkCmdPushDescriptorSetKHR( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - u32 set, - u32 descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites) { -} - -@extension("VK_EXT_conditional_rendering") // 82 -cmd void vkCmdBeginConditionalRenderingEXT( - VkCommandBuffer commandBuffer, - const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { -} - -@extension("VK_EXT_conditional_rendering") // 82 -cmd void vkCmdEndConditionalRenderingEXT( - VkCommandBuffer commandBuffer) { -} - -@extension("VK_KHR_descriptor_update_template") // 86 -cmd VkResult vkCreateDescriptorUpdateTemplateKHR( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) { - return ? -} - -@extension("VK_KHR_descriptor_update_template") // 86 -cmd void vkDestroyDescriptorUpdateTemplateKHR( - VkDevice device, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator) { -} - -@extension("VK_KHR_descriptor_update_template") // 86 -cmd void vkUpdateDescriptorSetWithTemplateKHR( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const void* pData) { -} - -@extension("VK_KHR_descriptor_update_template") // 86 -cmd void vkCmdPushDescriptorSetWithTemplateKHR( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - VkPipelineLayout layout, - u32 set, - const void* pData) { -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd void vkCmdProcessCommandsNVX( - VkCommandBuffer commandBuffer, - const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) { -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd void vkCmdReserveSpaceForCommandsNVX( - VkCommandBuffer commandBuffer, - const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) { -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd VkResult vkCreateIndirectCommandsLayoutNVX( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) { - return ? -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd void vkDestroyIndirectCommandsLayoutNVX( - VkDevice device, - VkIndirectCommandsLayoutNVX indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator) { -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd VkResult vkCreateObjectTableNVX( - VkDevice device, - const VkObjectTableCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkObjectTableNVX* pObjectTable) { - return ? -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd void vkDestroyObjectTableNVX( - VkDevice device, - VkObjectTableNVX objectTable, - const VkAllocationCallbacks* pAllocator) { -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd VkResult vkRegisterObjectsNVX( - VkDevice device, - VkObjectTableNVX objectTable, - u32 objectCount, - const VkObjectTableEntryNVX* const* ppObjectTableEntries, - const u32* pObjectIndices) { - return ? -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd VkResult vkUnregisterObjectsNVX( - VkDevice device, - VkObjectTableNVX objectTable, - u32 objectCount, - const VkObjectEntryTypeNVX* pObjectEntryTypes, - const u32* pObjectIndices) { - return ? -} - -@extension("VK_NVX_device_generated_commands") // 87 -cmd void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( - VkPhysicalDevice physicalDevice, - VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, - VkDeviceGeneratedCommandsLimitsNVX* pLimits) { -} - -@extension("VK_NV_clip_space_w_scaling") // 88 -cmd void vkCmdSetViewportWScalingNV( - VkCommandBuffer commandBuffer, - u32 firstViewport, - u32 viewportCount, - const VkViewportWScalingNV* pViewportWScalings) { -} - -@extension("VK_EXT_direct_mode_display") // 89 -cmd VkResult vkReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display) { - return ? -} - -@extension("VK_EXT_acquire_xlib_display") // 90 -cmd VkResult vkAcquireXlibDisplayEXT( - VkPhysicalDevice physicalDevice, - platform.Display* dpy, - VkDisplayKHR display) { - return ? -} - -@extension("VK_EXT_acquire_xlib_display") // 90 -cmd VkResult vkGetRandROutputDisplayEXT( - VkPhysicalDevice physicalDevice, - platform.Display* dpy, - platform.RROutput rrOutput, - VkDisplayKHR* pDisplay) { - return ? -} - -@extension("VK_EXT_display_surface_counter") // 91 -cmd VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { - return ? -} - -@extension("VK_EXT_display_control") // 92 -cmd VkResult vkDisplayPowerControlEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { - return ? -} - -@extension("VK_EXT_display_control") // 92 -cmd VkResult vkRegisterDeviceEventEXT( - VkDevice device, - const VkDeviceEventInfoEXT* pDeviceEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) { - return ? -} - -@extension("VK_EXT_display_control") // 92 -cmd VkResult vkRegisterDisplayEventEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayEventInfoEXT* pDisplayEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) { - return ? -} - -@extension("VK_EXT_display_control") // 92 -cmd VkResult vkGetSwapchainCounterEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSurfaceCounterFlagBitsEXT counter, - u64* pCounterValue) { - return ? -} - -@extension("VK_GOOGLE_display_timing") // 93 -cmd VkResult vkGetRefreshCycleDurationGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { - deviceObject := GetDevice(device) - swapchainObject := GetSwapchain(swapchain) - - displayTimingProperties := ? - pDisplayTimingProperties[0] = displayTimingProperties - - return ? -} - -@extension("VK_GOOGLE_display_timing") // 93 -cmd VkResult vkGetPastPresentationTimingGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - u32* pPresentationTimingCount, - VkPastPresentationTimingGOOGLE* pPresentationTimings) { - return ? -} - -@extension("VK_EXT_discard_rectangles") // 100 -cmd void vkCmdSetDiscardRectangleEXT( - VkCommandBuffer commandBuffer, - u32 firstDiscardRectangle, - u32 discardRectangleCount, - const VkRect2D* pDiscardRectangles) { -} - -@extension("VK_EXT_hdr_metadata") // 106 -cmd void vkSetHdrMetadataEXT( - VkDevice device, - u32 swapchainCount, - const VkSwapchainKHR* pSwapchains, - const VkHdrMetadataEXT* pMetadata) { -} - -@extension("VK_KHR_create_renderpass2") // 110 -cmd VkResult vkCreateRenderPass2KHR( - VkDevice device, - const VkRenderPassCreateInfo2KHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass) { - return ? -} - -@extension("VK_KHR_create_renderpass2") // 110 -cmd void vkCmdBeginRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfoKHR* pSubpassBeginInfo) { -} - -@extension("VK_KHR_create_renderpass2") // 110 -cmd void vkCmdNextSubpass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfoKHR* pSubpassBeginInfo, - const VkSubpassEndInfoKHR* pSubpassEndInfo) { -} - -@extension("VK_KHR_create_renderpass2") // 110 -cmd void vkCmdEndRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfoKHR* pSubpassEndInfo) { -} - -@extension("VK_KHR_shared_presentable_image") // 112 -cmd VkResult vkGetSwapchainStatusKHR( - VkDevice device, - VkSwapchainKHR swapchain) { - return ? -} - -@extension("VK_KHR_external_fence_capabilities") // 113 -cmd void vkGetPhysicalDeviceExternalFencePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, - VkExternalFencePropertiesKHR* pExternalFenceProperties) { -} - -@extension("VK_KHR_external_fence_win32") // 115 -cmd VkResult vkImportFenceWin32HandleKHR( - VkDevice device, - const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { - return ? -} - -@extension("VK_KHR_external_fence_win32") // 115 -cmd VkResult vkGetFenceWin32HandleKHR( - VkDevice device, - const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, - platform.HANDLE* pHandle) { - return ? -} - -@extension("VK_KHR_external_fence_fd") // 116 -cmd VkResult vkImportFenceFdKHR( - VkDevice device, - const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { - return ? -} - -@extension("VK_KHR_external_fence_fd") // 116 -cmd VkResult vkGetFenceFdKHR( - VkDevice device, - const VkFenceGetFdInfoKHR* pGetFdInfo, - int* pFd) { - return ? -} - -@extension("VK_KHR_get_surface_capabilities2") // 120 -cmd VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { - return ? -} - -@extension("VK_KHR_get_surface_capabilities2") // 120 -cmd VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - u32* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats) { - return ? -} - -@extension("VK_KHR_display_properties2") // 122 -cmd VkResult vkGetPhysicalDeviceDisplayProperties2KHR( - VkPhysicalDevice physicalDevice, - u32* pPropertyCount, - VkDisplayProperties2KHR* pProperties) { - return ? -} - -@extension("VK_KHR_display_properties2") // 122 -cmd VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( - VkPhysicalDevice physicalDevice, - u32* pPropertyCount, - VkDisplayPlaneProperties2KHR* pProperties) { - return ? -} - -@extension("VK_KHR_display_properties2") // 122 -cmd VkResult vkGetDisplayModeProperties2KHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - u32* pPropertyCount, - VkDisplayModeProperties2KHR* pProperties) { - return ? -} - -@extension("VK_KHR_display_properties2") // 122 -cmd VkResult vkGetDisplayPlaneCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, - VkDisplayPlaneCapabilities2KHR* pCapabilities) { - return ? -} - -@extension("VK_MVK_ios_surface") // 123 -cmd VkResult vkCreateIOSSurfaceMVK( - VkInstance instance, - const VkIOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - return ? -} - -@extension("VK_MVK_macos_surface") // 124 -cmd VkResult vkCreateMacOSSurfaceMVK( - VkInstance instance, - const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - return ? -} - -@extension("VK_EXT_debug_utils") // 129 -@external type void* PFN_vkDebugUtilsMessengerCallbackEXT -@extension("VK_EXT_debug_utils") // 129 -@pfn cmd VkBool32 vkDebugUtilsMessengerCallbackEXT( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageType, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData) { - return ? -} - -@extension("VK_EXT_debug_utils") // 129 -cmd VkResult vkSetDebugUtilsObjectNameEXT( - VkDevice device, - const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { - return ? -} - -@extension("VK_EXT_debug_utils") // 129 -cmd VkResult vkSetDebugUtilsObjectTagEXT( - VkDevice device, - const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { - return ? -} - -@extension("VK_EXT_debug_utils") // 129 -cmd void vkQueueBeginDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo) { -} - -@extension("VK_EXT_debug_utils") // 129 -cmd void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) { -} - -@extension("VK_EXT_debug_utils") // 129 -cmd void vkQueueInsertDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo) { -} - -@extension("VK_EXT_debug_utils") // 129 -cmd void vkCmdBeginDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo) { -} - -@extension("VK_EXT_debug_utils") // 129 -cmd void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { -} - -@extension("VK_EXT_debug_utils") // 129 -cmd void vkCmdInsertDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo) { -} - -@extension("VK_EXT_debug_utils") // 129 -cmd VkResult vkCreateDebugUtilsMessengerEXT( - VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pMessenger) { - return ? -} - -@extension("VK_EXT_debug_utils") // 129 -cmd void vkDestroyDebugUtilsMessengerEXT( - VkInstance instance, - VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks* pAllocator) { -} - -@extension("VK_EXT_debug_utils") // 129 -cmd void vkSubmitDebugUtilsMessageEXT( - VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { -} - -@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 -@vulkan1_1 // extension requires 1.1, and should become non-optional when 1.1 does -cmd VkResult vkGetAndroidHardwareBufferPropertiesANDROID( - VkDevice device, - const platform.AHardwareBuffer* buffer, - VkAndroidHardwareBufferPropertiesANDROID* pProperties) { - return ? -} - -@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130 -@vulkan1_1 // extension requires 1.1, and should become non-optional when 1.1 does -cmd VkResult vkGetMemoryAndroidHardwareBufferANDROID( - VkDevice device, - const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, - platform.AHardwareBuffer** pBuffer) { - return ? -} - -@extension("VK_EXT_sample_locations") // 144 -cmd void vkCmdSetSampleLocationsEXT( - VkCommandBuffer commandBuffer, - const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { -} - -@extension("VK_EXT_sample_locations") // 144 -cmd void vkGetPhysicalDeviceMultisamplePropertiesEXT( - VkPhysicalDevice physicalDevice, - VkSampleCountFlagBits samples, - VkMultisamplePropertiesEXT* pMultisampleProperties) { -} - -@extension("VK_KHR_get_memory_requirements2") // 147 -cmd void vkGetImageMemoryRequirements2KHR( - VkDevice device, - const VkImageMemoryRequirementsInfo2KHR* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements) { -} - -@extension("VK_KHR_get_memory_requirements2") // 147 -cmd void vkGetBufferMemoryRequirements2KHR( - VkDevice device, - const VkBufferMemoryRequirementsInfo2KHR* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements) { -} - -@extension("VK_KHR_get_memory_requirements2") // 147 -cmd void vkGetImageSparseMemoryRequirements2KHR( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, - u32* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) { -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -cmd VkResult vkCreateSamplerYcbcrConversionKHR( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversionKHR* pYcbcrConversion) { - return ? -} - -@extension("VK_KHR_sampler_ycbcr_conversion") // 157 -cmd void vkDestroySamplerYcbcrConversionKHR( - VkDevice device, - VkSamplerYcbcrConversionKHR ycbcrConversion, - const VkAllocationCallbacks* pAllocator) { -} - -@extension("VK_KHR_bind_memory2") // 158 -cmd VkResult vkBindBufferMemory2KHR( - VkDevice device, - u32 bindInfoCount, - const VkBindBufferMemoryInfoKHR* pBindInfos) { - return ? -} - -@extension("VK_KHR_bind_memory2") // 158 -cmd VkResult vkBindImageMemory2KHR( - VkDevice device, - u32 bindInfoCount, - const VkBindImageMemoryInfoKHR* pBindInfos) { - return ? -} - -@extension("VK_EXT_image_drm_format_modifier") // 159 -cmd VkResult vkGetImageDrmFormatModifierPropertiesEXT( - VkDevice device, - VkImage image, - VkImageDrmFormatModifierPropertiesEXT* pProperties) { - return ? -} - -@extension("VK_EXT_validation_cache") // 161 -cmd VkResult vkCreateValidationCacheEXT( - VkDevice device, - const VkValidationCacheCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkValidationCacheEXT* pValidationCache) { - return ? -} - -@extension("VK_EXT_validation_cache") // 161 -cmd void vkDestroyValidationCacheEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - const VkAllocationCallbacks* pAllocator) { -} - -@extension("VK_EXT_validation_cache") // 161 -cmd VkResult vkMergeValidationCachesEXT( - VkDevice device, - VkValidationCacheEXT dstCache, - u32 srcCacheCount, - const VkValidationCacheEXT* pSrcCaches) { - return ? -} - -@extension("VK_EXT_validation_cache") // 161 -cmd VkResult vkGetValidationCacheDataEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - platform.size_t* pDataSize, - void* pData) { - return ? -} - -@extension("VK_NV_shading_rate_image") // 165 -cmd void vkCmdBindShadingRateImageNV( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout) { -} - -@extension("VK_NV_shading_rate_image") // 165 -cmd void vkCmdSetViewportShadingRatePaletteNV( - VkCommandBuffer commandBuffer, - u32 firstViewport, - u32 viewportCount, - const VkShadingRatePaletteNV* pShadingRatePalettes) { -} - -@extension("VK_NV_shading_rate_image") // 165 -cmd void vkCmdSetCoarseSampleOrderNV( - VkCommandBuffer commandBuffer, - VkCoarseSampleOrderTypeNV sampleOrderType, - u32 customSampleOrderCount, - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { -} - -@extension("VK_NV_ray_tracing") // 166 -cmd VkResult vkCreateAccelerationStructureNV( - VkDevice device, - const VkAccelerationStructureCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureNV* pAccelerationStructure) { - return ? -} - -@extension("VK_NV_ray_tracing") // 166 -cmd void vkDestroyAccelerationStructureNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - const VkAllocationCallbacks* pAllocator) { -} - -@extension("VK_NV_ray_tracing") // 166 -cmd void vkGetAccelerationStructureMemoryRequirementsNV( - VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements) { -} - -@extension("VK_NV_ray_tracing") // 166 -cmd VkResult vkBindAccelerationStructureMemoryNV( - VkDevice device, - u32 bindInfoCount, - const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { - return ? -} - -@extension("VK_NV_ray_tracing") // 166 -cmd void vkCmdBuildAccelerationStructureNV( - VkCommandBuffer commandBuffer, - const VkAccelerationStructureInfoNV* pInfo, - VkBuffer instanceData, - VkDeviceSize instanceOffset, - VkBool32 update, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkBuffer scratch, - VkDeviceSize scratchOffset) { -} - -@extension("VK_NV_ray_tracing") // 166 -cmd void vkCmdCopyAccelerationStructureNV( - VkCommandBuffer commandBuffer, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkCopyAccelerationStructureModeNV mode) { -} - -@extension("VK_NV_ray_tracing") // 166 -cmd void vkCmdTraceRaysNV( - VkCommandBuffer commandBuffer, - VkBuffer raygenShaderBindingTableBuffer, - VkDeviceSize raygenShaderBindingOffset, - VkBuffer missShaderBindingTableBuffer, - VkDeviceSize missShaderBindingOffset, - VkDeviceSize missShaderBindingStride, - VkBuffer hitShaderBindingTableBuffer, - VkDeviceSize hitShaderBindingOffset, - VkDeviceSize hitShaderBindingStride, - VkBuffer callableShaderBindingTableBuffer, - VkDeviceSize callableShaderBindingOffset, - VkDeviceSize callableShaderBindingStride, - u32 width, - u32 height, - u32 depth) { -} - -@extension("VK_NV_ray_tracing") // 166 -cmd VkResult vkCreateRaytracingPipelinesNV( - VkDevice device, - VkPipelineCache pipelineCache, - u32 createInfoCount, - const VkRayTracingPipelineCreateInfoNV* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) { - return ? -} - -@extension("VK_NV_ray_tracing") // 166 -cmd VkResult vkGetRaytracingShaderHandlesNV( - VkDevice device, - VkPipeline pipeline, - u32 firstGroup, - u32 groupCount, - platform.size_t dataSize, - void* pData) { - return ? -} - -@extension("VK_NV_ray_tracing") // 166 -cmd VkResult vkGetAccelerationStructureHandleNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - platform.size_t dataSize, - void* pData) { - return ? -} - -@extension("VK_NV_ray_tracing") // 166 -cmd void vkCmdWriteAccelerationStructurePropertiesNV( - VkCommandBuffer commandBuffer, - u32 accelerationStructureCount, - const VkAccelerationStructureNV* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - u32 firstQuery) { -} - -@extension("VK_NV_ray_tracing") // 166 -cmd VkResult vkCompileDeferredNV( - VkDevice device, - VkPipeline pipeline, - u32 shader) { - return ? -} - -@extension("VK_KHR_maintenance3") // 169 -cmd void vkGetDescriptorSetLayoutSupportKHR( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupportKHR* pSupport) { -} - -@extension("VK_KHR_draw_indirect_count") // 170 -cmd void vkCmdDrawIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - u32 maxDrawCount, - u32 stride) { -} - -@extension("VK_KHR_draw_indirect_count") // 170 -cmd void vkCmdDrawIndexedIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - u32 maxDrawCount, - u32 stride) { -} - -@extension("VK_EXT_external_memory_host") // 179 -cmd VkResult vkGetMemoryHostPointerPropertiesEXT( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void* pHostPointer, - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { - return ? -} - -@extension("VK_AMD_buffer_marker") // 180 -cmd void vkCmdWriteBufferMarkerAMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - u32 marker) { -} - -@extension("VK_EXT_calibrated_timestamps") // 185 -cmd VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( - VkPhysicalDevice physicalDevice, - u32* pTimeDomainCount, - VkTimeDomainEXT* pTimeDomains) { - return ? -} - -@extension("VK_EXT_calibrated_timestamps") // 185 -cmd VkResult vkGetCalibratedTimestampsEXT( - VkDevice device, - u32 timestampCount, - const VkCalibratedTimestampInfoEXT* pTimestampInfos, - u64* pTimestamps, - u64* pMaxDeviation) { - return ? -} - -@extension("VK_NV_mesh_shader") // 203 -cmd void vkCmdDrawMeshTasksNV( - VkCommandBuffer commandBuffer, - u32 taskCount, - u32 firstTask) { -} - -@extension("VK_NV_mesh_shader") // 203 -cmd void vkCmdDrawMeshTasksIndirectNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - u32 drawCount, - u32 stride) { -} - -@extension("VK_NV_mesh_shader") // 203 -cmd void vkCmdDrawMeshTasksIndirectCountNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - u32 maxDrawCount, - u32 stride) { -} - -@extension("VK_NV_scissor_exclusive") // 206 -cmd void vkCmdSetExclusiveScissorNV( - VkCommandBuffer commandBuffer, - u32 firstExclusiveScissor, - u32 exclusiveScissorCount, - const VkRect2D* pExclusiveScissors) { -} - -@extension("VK_NV_device_diagnostic_checkpoints") // 207 -cmd void vkCmdSetCheckpointNV( - VkCommandBuffer commandBuffer, - const void* pCheckpointMarker) { -} - -@extension("VK_NV_device_diagnostic_checkpoints") // 207 -cmd void vkGetQueueCheckpointDataNV( - VkQueue queue, - u32* pCheckpointDataCount, - VkCheckpointDataNV* pCheckpointData) { -} - -@extension("VK_FUCHSIA_imagepipe_surface") // 215 -cmd VkResult vkCreateImagePipeSurfaceFUCHSIA( - VkInstance instance, - const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) { - return ? -} - - -//////////////// -// Validation // -//////////////// - -extern void validate(string layerName, bool condition, string message) - - -///////////////////////////// -// Internal State Tracking // -///////////////////////////// - -StateObject State - -@internal class StateObject { - // Dispatchable objects. - map!(VkInstance, ref!InstanceObject) Instances - map!(VkPhysicalDevice, ref!PhysicalDeviceObject) PhysicalDevices - map!(VkDevice, ref!DeviceObject) Devices - map!(VkQueue, ref!QueueObject) Queues - map!(VkCommandBuffer, ref!CommandBufferObject) CommandBuffers - - // Non-dispatchable objects. - map!(VkDeviceMemory, ref!DeviceMemoryObject) DeviceMemories - map!(VkBuffer, ref!BufferObject) Buffers - map!(VkBufferView, ref!BufferViewObject) BufferViews - map!(VkImage, ref!ImageObject) Images - map!(VkImageView, ref!ImageViewObject) ImageViews - map!(VkShaderModule, ref!ShaderModuleObject) ShaderModules - map!(VkPipeline, ref!PipelineObject) Pipelines - map!(VkPipelineLayout, ref!PipelineLayoutObject) PipelineLayouts - map!(VkSampler, ref!SamplerObject) Samplers - map!(VkDescriptorSet, ref!DescriptorSetObject) DescriptorSets - map!(VkDescriptorSetLayout, ref!DescriptorSetLayoutObject) DescriptorSetLayouts - map!(VkDescriptorPool, ref!DescriptorPoolObject) DescriptorPools - map!(VkFence, ref!FenceObject) Fences - map!(VkSemaphore, ref!SemaphoreObject) Semaphores - map!(VkEvent, ref!EventObject) Events - map!(VkQueryPool, ref!QueryPoolObject) QueryPools - map!(VkFramebuffer, ref!FramebufferObject) Framebuffers - map!(VkRenderPass, ref!RenderPassObject) RenderPasses - map!(VkPipelineCache, ref!PipelineCacheObject) PipelineCaches - map!(VkCommandPool, ref!CommandPoolObject) CommandPools - map!(VkSurfaceKHR, ref!SurfaceObject) Surfaces - map!(VkSwapchainKHR, ref!SwapchainObject) Swapchains -} - -@internal class InstanceObject { -} - -@internal class PhysicalDeviceObject { - VkInstance instance -} - -@internal class DeviceObject { - VkPhysicalDevice physicalDevice -} - -@internal class QueueObject { - VkDevice device - VkQueueFlags flags -} - -@internal class CommandBufferObject { - VkDevice device - map!(u64, VkDeviceMemory) boundObjects - VkQueueFlags queueFlags -} - -@internal class DeviceMemoryObject { - VkDevice device - VkDeviceSize allocationSize - map!(u64, VkDeviceSize) boundObjects - map!(VkCommandBuffer, VkCommandBuffer) boundCommandBuffers -} - -@internal class BufferObject { - VkDevice device - VkDeviceMemory memory - VkDeviceSize memoryOffset -} - -@internal class BufferViewObject { - VkDevice device - VkBuffer buffer -} - -@internal class ImageObject { - VkDevice device - VkDeviceMemory memory - VkDeviceSize memoryOffset -} - -@internal class ImageViewObject { - VkDevice device - VkImage image -} - -@internal class ShaderObject { - VkDevice device -} - -@internal class ShaderModuleObject { - VkDevice device -} - -@internal class PipelineObject { - VkDevice device -} - -@internal class PipelineLayoutObject { - VkDevice device -} - -@internal class SamplerObject { - VkDevice device -} - -@internal class DescriptorSetObject { - VkDevice device -} - -@internal class DescriptorSetLayoutObject { - VkDevice device -} - -@internal class DescriptorPoolObject { - VkDevice device -} - -@internal class FenceObject { - VkDevice device - bool signaled -} - -@internal class SemaphoreObject { - VkDevice device -} - -@internal class EventObject { - VkDevice device -} - -@internal class QueryPoolObject { - VkDevice device -} - -@internal class FramebufferObject { - VkDevice device -} - -@internal class RenderPassObject { - VkDevice device -} - -@internal class PipelineCacheObject { - VkDevice device -} - -@internal class CommandPoolObject { - VkDevice device -} - -@internal class SurfaceObject { - VkInstance instance -} - -@internal class SwapchainObject { - VkDevice device -} - -macro ref!InstanceObject GetInstance(VkInstance instance) { - assert(instance in State.Instances) - return State.Instances[instance] -} - -macro ref!PhysicalDeviceObject GetPhysicalDevice(VkPhysicalDevice physicalDevice) { - assert(physicalDevice in State.PhysicalDevices) - return State.PhysicalDevices[physicalDevice] -} - -macro ref!DeviceObject GetDevice(VkDevice device) { - assert(device in State.Devices) - return State.Devices[device] -} - -macro ref!QueueObject GetQueue(VkQueue queue) { - assert(queue in State.Queues) - return State.Queues[queue] -} - -macro ref!CommandBufferObject GetCommandBuffer(VkCommandBuffer commandBuffer) { - assert(commandBuffer in State.CommandBuffers) - return State.CommandBuffers[commandBuffer] -} - -macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory memory) { - assert(memory in State.DeviceMemories) - return State.DeviceMemories[memory] -} - -macro ref!BufferObject GetBuffer(VkBuffer buffer) { - assert(buffer in State.Buffers) - return State.Buffers[buffer] -} - -macro ref!BufferViewObject GetBufferView(VkBufferView bufferView) { - assert(bufferView in State.BufferViews) - return State.BufferViews[bufferView] -} - -macro ref!ImageObject GetImage(VkImage image) { - assert(image in State.Images) - return State.Images[image] -} - -macro ref!ImageViewObject GetImageView(VkImageView imageView) { - assert(imageView in State.ImageViews) - return State.ImageViews[imageView] -} - -macro ref!ShaderModuleObject GetShaderModule(VkShaderModule shaderModule) { - assert(shaderModule in State.ShaderModules) - return State.ShaderModules[shaderModule] -} - -macro ref!PipelineObject GetPipeline(VkPipeline pipeline) { - assert(pipeline in State.Pipelines) - return State.Pipelines[pipeline] -} - -macro ref!PipelineLayoutObject GetPipelineLayout(VkPipelineLayout pipelineLayout) { - assert(pipelineLayout in State.PipelineLayouts) - return State.PipelineLayouts[pipelineLayout] -} - -macro ref!SamplerObject GetSampler(VkSampler sampler) { - assert(sampler in State.Samplers) - return State.Samplers[sampler] -} - -macro ref!DescriptorSetObject GetDescriptorSet(VkDescriptorSet descriptorSet) { - assert(descriptorSet in State.DescriptorSets) - return State.DescriptorSets[descriptorSet] -} - -macro ref!DescriptorSetLayoutObject GetDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) { - assert(descriptorSetLayout in State.DescriptorSetLayouts) - return State.DescriptorSetLayouts[descriptorSetLayout] -} - -macro ref!DescriptorPoolObject GetDescriptorPool(VkDescriptorPool descriptorPool) { - assert(descriptorPool in State.DescriptorPools) - return State.DescriptorPools[descriptorPool] -} - -macro ref!FenceObject GetFence(VkFence fence) { - assert(fence in State.Fences) - return State.Fences[fence] -} - -macro ref!SemaphoreObject GetSemaphore(VkSemaphore semaphore) { - assert(semaphore in State.Semaphores) - return State.Semaphores[semaphore] -} - -macro ref!EventObject GetEvent(VkEvent event) { - assert(event in State.Events) - return State.Events[event] -} - -macro ref!QueryPoolObject GetQueryPool(VkQueryPool queryPool) { - assert(queryPool in State.QueryPools) - return State.QueryPools[queryPool] -} - -macro ref!FramebufferObject GetFramebuffer(VkFramebuffer framebuffer) { - assert(framebuffer in State.Framebuffers) - return State.Framebuffers[framebuffer] -} - -macro ref!RenderPassObject GetRenderPass(VkRenderPass renderPass) { - assert(renderPass in State.RenderPasses) - return State.RenderPasses[renderPass] -} - -macro ref!PipelineCacheObject GetPipelineCache(VkPipelineCache pipelineCache) { - assert(pipelineCache in State.PipelineCaches) - return State.PipelineCaches[pipelineCache] -} - -macro ref!CommandPoolObject GetCommandPool(VkCommandPool commandPool) { - assert(commandPool in State.CommandPools) - return State.CommandPools[commandPool] -} - -macro ref!SurfaceObject GetSurface(VkSurfaceKHR surface) { - assert(surface in State.Surfaces) - return State.Surfaces[surface] -} - -macro ref!SwapchainObject GetSwapchain(VkSwapchainKHR swapchain) { - assert(swapchain in State.Swapchains) - return State.Swapchains[swapchain] -} - -macro VkQueueFlags AddQueueFlag(VkQueueFlags flags, VkQueueFlagBits bit) { - return as!VkQueueFlags(as!u32(flags) | as!u32(bit)) -} diff --git a/vulkan/include/vulkan/vk_android_native_buffer.h b/vulkan/include/vulkan/vk_android_native_buffer.h index 23006fa6be..9ffe83ba2e 100644 --- a/vulkan/include/vulkan/vk_android_native_buffer.h +++ b/vulkan/include/vulkan/vk_android_native_buffer.h @@ -62,6 +62,11 @@ typedef enum VkSwapchainImageUsageFlagBitsANDROID { typedef VkFlags VkSwapchainImageUsageFlagsANDROID; typedef struct { + uint64_t consumer; + uint64_t producer; +} VkNativeBufferUsage2ANDROID; + +typedef struct { VkStructureType sType; // must be VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID const void* pNext; @@ -73,10 +78,7 @@ typedef struct { int format; int usage; // DEPRECATED in SPEC_VERSION 6 // -- Added in SPEC_VERSION 6 -- - struct { - uint64_t consumer; - uint64_t producer; - } usage2; + VkNativeBufferUsage2ANDROID usage2; } VkNativeBufferANDROID; typedef struct { diff --git a/vulkan/libvulkan/api.cpp b/vulkan/libvulkan/api.cpp index 71048db920..368130d13b 100644 --- a/vulkan/libvulkan/api.cpp +++ b/vulkan/libvulkan/api.cpp @@ -664,6 +664,12 @@ VkResult LayerChain::LoadLayer(ActiveLayer& layer, const char* name) { return VK_ERROR_LAYER_NOT_PRESENT; } + if (!layer.ref.GetGetInstanceProcAddr()) { + ALOGW("Failed to locate vkGetInstanceProcAddr in layer %s", name); + layer.ref.~LayerRef(); + return VK_ERROR_LAYER_NOT_PRESENT; + } + ALOGI("Loaded layer %s", name); return VK_SUCCESS; diff --git a/vulkan/libvulkan/api_gen.cpp b/vulkan/libvulkan/api_gen.cpp index ad46c3bf93..37b5368452 100644 --- a/vulkan/libvulkan/api_gen.cpp +++ b/vulkan/libvulkan/api_gen.cpp @@ -54,6 +54,11 @@ namespace { // clang-format off +VKAPI_ATTR VkResult disabledCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR*, const VkAllocationCallbacks*, VkSurfaceKHR*) { + driver::Logger(instance).Err(instance, "VK_KHR_android_surface not enabled. Exported vkCreateAndroidSurfaceKHR not executed."); + return VK_SUCCESS; +} + VKAPI_ATTR void disabledDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR, const VkAllocationCallbacks*) { driver::Logger(instance).Err(instance, "VK_KHR_surface not enabled. Exported vkDestroySurfaceKHR not executed."); } @@ -112,18 +117,13 @@ VKAPI_ATTR VkResult disabledGetDeviceGroupSurfacePresentModesKHR(VkDevice device return VK_SUCCESS; } -VKAPI_ATTR VkResult disabledGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR, uint32_t*, VkRect2D*) { - driver::Logger(physicalDevice).Err(physicalDevice, "VK_KHR_swapchain not enabled. Exported vkGetPhysicalDevicePresentRectanglesKHR not executed."); - return VK_SUCCESS; -} - VKAPI_ATTR VkResult disabledAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR*, uint32_t*) { driver::Logger(device).Err(device, "VK_KHR_swapchain not enabled. Exported vkAcquireNextImage2KHR not executed."); return VK_SUCCESS; } -VKAPI_ATTR VkResult disabledCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR*, const VkAllocationCallbacks*, VkSurfaceKHR*) { - driver::Logger(instance).Err(instance, "VK_KHR_android_surface not enabled. Exported vkCreateAndroidSurfaceKHR not executed."); +VKAPI_ATTR VkResult disabledGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR, uint32_t*, VkRect2D*) { + driver::Logger(physicalDevice).Err(physicalDevice, "VK_KHR_swapchain not enabled. Exported vkGetPhysicalDevicePresentRectanglesKHR not executed."); return VK_SUCCESS; } @@ -161,7 +161,12 @@ bool InitDispatchTable( INIT_PROC(true, instance, CreateDevice); INIT_PROC(true, instance, EnumerateDeviceExtensionProperties); INIT_PROC(true, instance, GetPhysicalDeviceSparseImageFormatProperties); - INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); + INIT_PROC_EXT(KHR_android_surface, true, instance, CreateAndroidSurfaceKHR); + INIT_PROC_EXT(KHR_surface, true, instance, DestroySurfaceKHR); + INIT_PROC_EXT(KHR_surface, true, instance, GetPhysicalDeviceSurfaceSupportKHR); + INIT_PROC_EXT(KHR_surface, true, instance, GetPhysicalDeviceSurfaceCapabilitiesKHR); + INIT_PROC_EXT(KHR_surface, true, instance, GetPhysicalDeviceSurfaceFormatsKHR); + INIT_PROC_EXT(KHR_surface, true, instance, GetPhysicalDeviceSurfacePresentModesKHR); INIT_PROC(false, instance, GetPhysicalDeviceFeatures2); INIT_PROC(false, instance, GetPhysicalDeviceProperties2); INIT_PROC(false, instance, GetPhysicalDeviceFormatProperties2); @@ -170,15 +175,10 @@ bool InitDispatchTable( INIT_PROC(false, instance, GetPhysicalDeviceMemoryProperties2); INIT_PROC(false, instance, GetPhysicalDeviceSparseImageFormatProperties2); INIT_PROC(false, instance, GetPhysicalDeviceExternalBufferProperties); - INIT_PROC(false, instance, GetPhysicalDeviceExternalFenceProperties); INIT_PROC(false, instance, GetPhysicalDeviceExternalSemaphoreProperties); - INIT_PROC_EXT(KHR_surface, true, instance, DestroySurfaceKHR); - INIT_PROC_EXT(KHR_surface, true, instance, GetPhysicalDeviceSurfaceSupportKHR); - INIT_PROC_EXT(KHR_surface, true, instance, GetPhysicalDeviceSurfaceCapabilitiesKHR); - INIT_PROC_EXT(KHR_surface, true, instance, GetPhysicalDeviceSurfaceFormatsKHR); - INIT_PROC_EXT(KHR_surface, true, instance, GetPhysicalDeviceSurfacePresentModesKHR); + INIT_PROC(false, instance, GetPhysicalDeviceExternalFenceProperties); + INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); INIT_PROC_EXT(KHR_swapchain, false, instance, GetPhysicalDevicePresentRectanglesKHR); - INIT_PROC_EXT(KHR_android_surface, true, instance, CreateAndroidSurfaceKHR); // clang-format on return success; @@ -313,32 +313,32 @@ bool InitDispatchTable( INIT_PROC(true, dev, CmdNextSubpass); INIT_PROC(true, dev, CmdEndRenderPass); INIT_PROC(true, dev, CmdExecuteCommands); + INIT_PROC_EXT(KHR_swapchain, true, dev, CreateSwapchainKHR); + INIT_PROC_EXT(KHR_swapchain, true, dev, DestroySwapchainKHR); + INIT_PROC_EXT(KHR_swapchain, true, dev, GetSwapchainImagesKHR); + INIT_PROC_EXT(KHR_swapchain, true, dev, AcquireNextImageKHR); + INIT_PROC_EXT(KHR_swapchain, true, dev, QueuePresentKHR); + INIT_PROC(false, dev, TrimCommandPool); + INIT_PROC(false, dev, GetDeviceGroupPeerMemoryFeatures); INIT_PROC(false, dev, BindBufferMemory2); INIT_PROC(false, dev, BindImageMemory2); - INIT_PROC(false, dev, GetDeviceGroupPeerMemoryFeatures); INIT_PROC(false, dev, CmdSetDeviceMask); + INIT_PROC_EXT(KHR_swapchain, false, dev, GetDeviceGroupPresentCapabilitiesKHR); + INIT_PROC_EXT(KHR_swapchain, false, dev, GetDeviceGroupSurfacePresentModesKHR); + INIT_PROC_EXT(KHR_swapchain, false, dev, AcquireNextImage2KHR); INIT_PROC(false, dev, CmdDispatchBase); - INIT_PROC(false, dev, GetImageMemoryRequirements2); + INIT_PROC(false, dev, CreateDescriptorUpdateTemplate); + INIT_PROC(false, dev, DestroyDescriptorUpdateTemplate); + INIT_PROC(false, dev, UpdateDescriptorSetWithTemplate); INIT_PROC(false, dev, GetBufferMemoryRequirements2); + INIT_PROC(false, dev, GetImageMemoryRequirements2); INIT_PROC(false, dev, GetImageSparseMemoryRequirements2); - INIT_PROC(false, dev, TrimCommandPool); - INIT_PROC(false, dev, GetDeviceQueue2); INIT_PROC(false, dev, CreateSamplerYcbcrConversion); INIT_PROC(false, dev, DestroySamplerYcbcrConversion); - INIT_PROC(false, dev, CreateDescriptorUpdateTemplate); - INIT_PROC(false, dev, DestroyDescriptorUpdateTemplate); - INIT_PROC(false, dev, UpdateDescriptorSetWithTemplate); + INIT_PROC(false, dev, GetDeviceQueue2); INIT_PROC(false, dev, GetDescriptorSetLayoutSupport); - INIT_PROC_EXT(KHR_swapchain, true, dev, CreateSwapchainKHR); - INIT_PROC_EXT(KHR_swapchain, true, dev, DestroySwapchainKHR); - INIT_PROC_EXT(KHR_swapchain, true, dev, GetSwapchainImagesKHR); - INIT_PROC_EXT(KHR_swapchain, true, dev, AcquireNextImageKHR); - INIT_PROC_EXT(KHR_swapchain, true, dev, QueuePresentKHR); - INIT_PROC_EXT(KHR_swapchain, false, dev, GetDeviceGroupPresentCapabilitiesKHR); - INIT_PROC_EXT(KHR_swapchain, false, dev, GetDeviceGroupSurfacePresentModesKHR); - INIT_PROC_EXT(KHR_swapchain, false, dev, AcquireNextImage2KHR); - INIT_PROC_EXT(ANDROID_external_memory_android_hardware_buffer, false, dev, GetAndroidHardwareBufferPropertiesANDROID); - INIT_PROC_EXT(ANDROID_external_memory_android_hardware_buffer, false, dev, GetMemoryAndroidHardwareBufferANDROID); + INIT_PROC_EXT(ANDROID_external_memory_android_hardware_buffer, true, dev, GetAndroidHardwareBufferPropertiesANDROID); + INIT_PROC_EXT(ANDROID_external_memory_android_hardware_buffer, true, dev, GetMemoryAndroidHardwareBufferANDROID); // clang-format on return success; @@ -478,33 +478,7 @@ VKAPI_ATTR void CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRender VKAPI_ATTR void CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents); VKAPI_ATTR void CmdEndRenderPass(VkCommandBuffer commandBuffer); VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -VKAPI_ATTR VkResult BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -VKAPI_ATTR VkResult BindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); -VKAPI_ATTR void GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -VKAPI_ATTR void CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); -VKAPI_ATTR void CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -VKAPI_ATTR VkResult EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -VKAPI_ATTR void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -VKAPI_ATTR void GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -VKAPI_ATTR void GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); -VKAPI_ATTR void TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); -VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR VkResult CreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -VKAPI_ATTR void DestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); -VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); -VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); -VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -VKAPI_ATTR void GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +VKAPI_ATTR VkResult CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); VKAPI_ATTR void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); @@ -515,11 +489,37 @@ VKAPI_ATTR void DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, c VKAPI_ATTR VkResult GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); VKAPI_ATTR VkResult AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); VKAPI_ATTR VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +VKAPI_ATTR void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +VKAPI_ATTR void GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +VKAPI_ATTR void GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +VKAPI_ATTR void TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +VKAPI_ATTR VkResult EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +VKAPI_ATTR void GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +VKAPI_ATTR VkResult BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +VKAPI_ATTR VkResult BindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +VKAPI_ATTR void CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); VKAPI_ATTR VkResult GetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); VKAPI_ATTR VkResult GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); -VKAPI_ATTR VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); VKAPI_ATTR VkResult AcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); -VKAPI_ATTR VkResult CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +VKAPI_ATTR void CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +VKAPI_ATTR VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +VKAPI_ATTR VkResult CreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +VKAPI_ATTR void DestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +VKAPI_ATTR void GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); VKAPI_ATTR VkResult GetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); VKAPI_ATTR VkResult GetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); @@ -621,9 +621,9 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha // global functions if (instance == VK_NULL_HANDLE) { if (strcmp(pName, "vkCreateInstance") == 0) return reinterpret_cast<PFN_vkVoidFunction>(CreateInstance); + if (strcmp(pName, "vkEnumerateInstanceVersion") == 0) return reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceVersion); if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceLayerProperties); if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties); - if (strcmp(pName, "vkEnumerateInstanceVersion") == 0) return reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceVersion); ALOGE("invalid vkGetInstanceProcAddr(VK_NULL_HANDLE, \"%s\") call", pName); return nullptr; @@ -1312,40 +1312,48 @@ VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t comma GetData(commandBuffer).dispatch.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); } -VKAPI_ATTR VkResult BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { - return GetData(device).dispatch.BindBufferMemory2(device, bindInfoCount, pBindInfos); +VKAPI_ATTR VkResult CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return GetData(instance).dispatch.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } -VKAPI_ATTR VkResult BindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { - return GetData(device).dispatch.BindImageMemory2(device, bindInfoCount, pBindInfos); +VKAPI_ATTR void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { + GetData(instance).dispatch.DestroySurfaceKHR(instance, surface, pAllocator); } -VKAPI_ATTR void GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { - GetData(device).dispatch.GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); +VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { + return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); } -VKAPI_ATTR void CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { - GetData(commandBuffer).dispatch.CmdSetDeviceMask(commandBuffer, deviceMask); +VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { + return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); } -VKAPI_ATTR void CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - GetData(commandBuffer).dispatch.CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { + return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); } -VKAPI_ATTR VkResult EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { - return GetData(instance).dispatch.EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); +VKAPI_ATTR VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { + return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); } -VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - GetData(device).dispatch.GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); +VKAPI_ATTR VkResult CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { + return GetData(device).dispatch.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); } -VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - GetData(device).dispatch.GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); +VKAPI_ATTR void DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { + GetData(device).dispatch.DestroySwapchainKHR(device, swapchain, pAllocator); } -VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { - GetData(device).dispatch.GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +VKAPI_ATTR VkResult GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { + return GetData(device).dispatch.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); +} + +VKAPI_ATTR VkResult AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { + return GetData(device).dispatch.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); +} + +VKAPI_ATTR VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { + return GetData(queue).dispatch.QueuePresentKHR(queue, pPresentInfo); } VKAPI_ATTR void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { @@ -1380,104 +1388,96 @@ VKAPI_ATTR void TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCo GetData(device).dispatch.TrimCommandPool(device, commandPool, flags); } -VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { - GetData(device).dispatch.GetDeviceQueue2(device, pQueueInfo, pQueue); -} - -VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { - return GetData(device).dispatch.CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); -} - -VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { - GetData(device).dispatch.DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); +VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { + GetData(physicalDevice).dispatch.GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } -VKAPI_ATTR VkResult CreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { - return GetData(device).dispatch.CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); +VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { + GetData(physicalDevice).dispatch.GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } -VKAPI_ATTR void DestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { - GetData(device).dispatch.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); +VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { + GetData(physicalDevice).dispatch.GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } -VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { - GetData(device).dispatch.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); +VKAPI_ATTR VkResult EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { + return GetData(instance).dispatch.EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); } -VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { - GetData(physicalDevice).dispatch.GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +VKAPI_ATTR void GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + GetData(device).dispatch.GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } -VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { - GetData(physicalDevice).dispatch.GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +VKAPI_ATTR VkResult BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { + return GetData(device).dispatch.BindBufferMemory2(device, bindInfoCount, pBindInfos); } -VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { - GetData(physicalDevice).dispatch.GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +VKAPI_ATTR VkResult BindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { + return GetData(device).dispatch.BindImageMemory2(device, bindInfoCount, pBindInfos); } -VKAPI_ATTR void GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { - GetData(device).dispatch.GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); +VKAPI_ATTR void CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { + GetData(commandBuffer).dispatch.CmdSetDeviceMask(commandBuffer, deviceMask); } -VKAPI_ATTR void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { - GetData(instance).dispatch.DestroySurfaceKHR(instance, surface, pAllocator); +VKAPI_ATTR VkResult GetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { + return GetData(device).dispatch.GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); } -VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { - return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); +VKAPI_ATTR VkResult GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { + return GetData(device).dispatch.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); } -VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { - return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); +VKAPI_ATTR VkResult AcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { + return GetData(device).dispatch.AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); } -VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { - return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); +VKAPI_ATTR void CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + GetData(commandBuffer).dispatch.CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } -VKAPI_ATTR VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { - return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); +VKAPI_ATTR VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { + return GetData(physicalDevice).dispatch.GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); } -VKAPI_ATTR VkResult CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { - return GetData(device).dispatch.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); +VKAPI_ATTR VkResult CreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { + return GetData(device).dispatch.CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); } -VKAPI_ATTR void DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { - GetData(device).dispatch.DestroySwapchainKHR(device, swapchain, pAllocator); +VKAPI_ATTR void DestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { + GetData(device).dispatch.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); } -VKAPI_ATTR VkResult GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { - return GetData(device).dispatch.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); +VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { + GetData(device).dispatch.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); } -VKAPI_ATTR VkResult AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { - return GetData(device).dispatch.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); +VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + GetData(device).dispatch.GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); } -VKAPI_ATTR VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { - return GetData(queue).dispatch.QueuePresentKHR(queue, pPresentInfo); +VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + GetData(device).dispatch.GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); } -VKAPI_ATTR VkResult GetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { - return GetData(device).dispatch.GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); +VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + GetData(device).dispatch.GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } -VKAPI_ATTR VkResult GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { - return GetData(device).dispatch.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); +VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { + return GetData(device).dispatch.CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); } -VKAPI_ATTR VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { - return GetData(physicalDevice).dispatch.GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); +VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { + GetData(device).dispatch.DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); } -VKAPI_ATTR VkResult AcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { - return GetData(device).dispatch.AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); +VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { + GetData(device).dispatch.GetDeviceQueue2(device, pQueueInfo, pQueue); } -VKAPI_ATTR VkResult CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - return GetData(instance).dispatch.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); +VKAPI_ATTR void GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { + GetData(device).dispatch.GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); } VKAPI_ATTR VkResult GetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { @@ -1564,6 +1564,11 @@ VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pA } __attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkEnumerateInstanceVersion(uint32_t* pApiVersion) { + return vulkan::api::EnumerateInstanceVersion(pApiVersion); +} + +__attribute__((visibility("default"))) VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) { return vulkan::api::EnumerateInstanceLayerProperties(pPropertyCount, pProperties); } @@ -2184,53 +2189,58 @@ VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t com } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkEnumerateInstanceVersion(uint32_t* pApiVersion) { - return vulkan::api::EnumerateInstanceVersion(pApiVersion); +VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vulkan::api::CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { - return vulkan::api::BindBufferMemory2(device, bindInfoCount, pBindInfos); +VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { + vulkan::api::DestroySurfaceKHR(instance, surface, pAllocator); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { - return vulkan::api::BindImageMemory2(device, bindInfoCount, pBindInfos); +VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { + return vulkan::api::GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { - vulkan::api::GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); +VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { + return vulkan::api::GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { - vulkan::api::CmdSetDeviceMask(commandBuffer, deviceMask); +VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { + return vulkan::api::GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - vulkan::api::CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { + return vulkan::api::GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { - return vulkan::api::EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); +VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { + return vulkan::api::CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - vulkan::api::GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); +VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { + vulkan::api::DestroySwapchainKHR(device, swapchain, pAllocator); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - vulkan::api::GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); +VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { + return vulkan::api::GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { - vulkan::api::GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { + return vulkan::api::AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { + return vulkan::api::QueuePresentKHR(queue, pPresentInfo); } __attribute__((visibility("default"))) @@ -2274,128 +2284,118 @@ VKAPI_ATTR void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, Vk } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { - vulkan::api::GetDeviceQueue2(device, pQueueInfo, pQueue); -} - -__attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { - return vulkan::api::CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); -} - -__attribute__((visibility("default"))) -VKAPI_ATTR void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { - vulkan::api::DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); +VKAPI_ATTR void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { + vulkan::api::GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { - return vulkan::api::CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); +VKAPI_ATTR void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { + vulkan::api::GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { - vulkan::api::DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); +VKAPI_ATTR void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { + vulkan::api::GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { - vulkan::api::UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); +VKAPI_ATTR VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { + return vulkan::api::EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { - vulkan::api::GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +VKAPI_ATTR void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + vulkan::api::GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { - vulkan::api::GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +VKAPI_ATTR VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { + return vulkan::api::BindBufferMemory2(device, bindInfoCount, pBindInfos); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { - vulkan::api::GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +VKAPI_ATTR VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { + return vulkan::api::BindImageMemory2(device, bindInfoCount, pBindInfos); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { - vulkan::api::GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); +VKAPI_ATTR void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { + vulkan::api::CmdSetDeviceMask(commandBuffer, deviceMask); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { - vulkan::api::DestroySurfaceKHR(instance, surface, pAllocator); +VKAPI_ATTR VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { + return vulkan::api::GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { - return vulkan::api::GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); +VKAPI_ATTR VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { + return vulkan::api::GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { - return vulkan::api::GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); +VKAPI_ATTR VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { + return vulkan::api::AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { - return vulkan::api::GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); +VKAPI_ATTR void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + vulkan::api::CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { - return vulkan::api::GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); +VKAPI_ATTR VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { + return vulkan::api::GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { - return vulkan::api::CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); +VKAPI_ATTR VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { + return vulkan::api::CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); } __attribute__((visibility("default"))) -VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { - vulkan::api::DestroySwapchainKHR(device, swapchain, pAllocator); +VKAPI_ATTR void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { + vulkan::api::DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { - return vulkan::api::GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); +VKAPI_ATTR void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { + vulkan::api::UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { - return vulkan::api::AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); +VKAPI_ATTR void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + vulkan::api::GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { - return vulkan::api::QueuePresentKHR(queue, pPresentInfo); +VKAPI_ATTR void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + vulkan::api::GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { - return vulkan::api::GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); +VKAPI_ATTR void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + vulkan::api::GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { - return vulkan::api::GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); +VKAPI_ATTR VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { + return vulkan::api::CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { - return vulkan::api::GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); +VKAPI_ATTR void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { + vulkan::api::DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { - return vulkan::api::AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); +VKAPI_ATTR void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { + vulkan::api::GetDeviceQueue2(device, pQueueInfo, pQueue); } __attribute__((visibility("default"))) -VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - return vulkan::api::CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); +VKAPI_ATTR void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { + vulkan::api::GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); } __attribute__((visibility("default"))) diff --git a/vulkan/libvulkan/api_gen.h b/vulkan/libvulkan/api_gen.h index f5822249b3..21958454f5 100644 --- a/vulkan/libvulkan/api_gen.h +++ b/vulkan/libvulkan/api_gen.h @@ -42,7 +42,12 @@ struct InstanceDispatchTable { PFN_vkCreateDevice CreateDevice; PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties; PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties; - PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; + PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR; + PFN_vkDestroySurfaceKHR DestroySurfaceKHR; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR; + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR; + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR; PFN_vkGetPhysicalDeviceFeatures2 GetPhysicalDeviceFeatures2; PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2; PFN_vkGetPhysicalDeviceFormatProperties2 GetPhysicalDeviceFormatProperties2; @@ -51,15 +56,10 @@ struct InstanceDispatchTable { PFN_vkGetPhysicalDeviceMemoryProperties2 GetPhysicalDeviceMemoryProperties2; PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 GetPhysicalDeviceSparseImageFormatProperties2; PFN_vkGetPhysicalDeviceExternalBufferProperties GetPhysicalDeviceExternalBufferProperties; - PFN_vkGetPhysicalDeviceExternalFenceProperties GetPhysicalDeviceExternalFenceProperties; PFN_vkGetPhysicalDeviceExternalSemaphoreProperties GetPhysicalDeviceExternalSemaphoreProperties; - PFN_vkDestroySurfaceKHR DestroySurfaceKHR; - PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR; - PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR; - PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR; - PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR; + PFN_vkGetPhysicalDeviceExternalFenceProperties GetPhysicalDeviceExternalFenceProperties; + PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; PFN_vkGetPhysicalDevicePresentRectanglesKHR GetPhysicalDevicePresentRectanglesKHR; - PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR; // clang-format on }; @@ -186,30 +186,30 @@ struct DeviceDispatchTable { PFN_vkCmdNextSubpass CmdNextSubpass; PFN_vkCmdEndRenderPass CmdEndRenderPass; PFN_vkCmdExecuteCommands CmdExecuteCommands; + PFN_vkCreateSwapchainKHR CreateSwapchainKHR; + PFN_vkDestroySwapchainKHR DestroySwapchainKHR; + PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR; + PFN_vkAcquireNextImageKHR AcquireNextImageKHR; + PFN_vkQueuePresentKHR QueuePresentKHR; + PFN_vkTrimCommandPool TrimCommandPool; + PFN_vkGetDeviceGroupPeerMemoryFeatures GetDeviceGroupPeerMemoryFeatures; PFN_vkBindBufferMemory2 BindBufferMemory2; PFN_vkBindImageMemory2 BindImageMemory2; - PFN_vkGetDeviceGroupPeerMemoryFeatures GetDeviceGroupPeerMemoryFeatures; PFN_vkCmdSetDeviceMask CmdSetDeviceMask; + PFN_vkGetDeviceGroupPresentCapabilitiesKHR GetDeviceGroupPresentCapabilitiesKHR; + PFN_vkGetDeviceGroupSurfacePresentModesKHR GetDeviceGroupSurfacePresentModesKHR; + PFN_vkAcquireNextImage2KHR AcquireNextImage2KHR; PFN_vkCmdDispatchBase CmdDispatchBase; - PFN_vkGetImageMemoryRequirements2 GetImageMemoryRequirements2; + PFN_vkCreateDescriptorUpdateTemplate CreateDescriptorUpdateTemplate; + PFN_vkDestroyDescriptorUpdateTemplate DestroyDescriptorUpdateTemplate; + PFN_vkUpdateDescriptorSetWithTemplate UpdateDescriptorSetWithTemplate; PFN_vkGetBufferMemoryRequirements2 GetBufferMemoryRequirements2; + PFN_vkGetImageMemoryRequirements2 GetImageMemoryRequirements2; PFN_vkGetImageSparseMemoryRequirements2 GetImageSparseMemoryRequirements2; - PFN_vkTrimCommandPool TrimCommandPool; - PFN_vkGetDeviceQueue2 GetDeviceQueue2; PFN_vkCreateSamplerYcbcrConversion CreateSamplerYcbcrConversion; PFN_vkDestroySamplerYcbcrConversion DestroySamplerYcbcrConversion; - PFN_vkCreateDescriptorUpdateTemplate CreateDescriptorUpdateTemplate; - PFN_vkDestroyDescriptorUpdateTemplate DestroyDescriptorUpdateTemplate; - PFN_vkUpdateDescriptorSetWithTemplate UpdateDescriptorSetWithTemplate; + PFN_vkGetDeviceQueue2 GetDeviceQueue2; PFN_vkGetDescriptorSetLayoutSupport GetDescriptorSetLayoutSupport; - PFN_vkCreateSwapchainKHR CreateSwapchainKHR; - PFN_vkDestroySwapchainKHR DestroySwapchainKHR; - PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR; - PFN_vkAcquireNextImageKHR AcquireNextImageKHR; - PFN_vkQueuePresentKHR QueuePresentKHR; - PFN_vkGetDeviceGroupPresentCapabilitiesKHR GetDeviceGroupPresentCapabilitiesKHR; - PFN_vkGetDeviceGroupSurfacePresentModesKHR GetDeviceGroupSurfacePresentModesKHR; - PFN_vkAcquireNextImage2KHR AcquireNextImage2KHR; PFN_vkGetAndroidHardwareBufferPropertiesANDROID GetAndroidHardwareBufferPropertiesANDROID; PFN_vkGetMemoryAndroidHardwareBufferANDROID GetMemoryAndroidHardwareBufferANDROID; // clang-format on diff --git a/vulkan/libvulkan/code-generator.tmpl b/vulkan/libvulkan/code-generator.tmpl deleted file mode 100644 index 940b747f1b..0000000000 --- a/vulkan/libvulkan/code-generator.tmpl +++ /dev/null @@ -1,1197 +0,0 @@ -{{define "Copyright"}} -/* -•* Copyright 2016 The Android Open Source Project -•* -•* 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. -•*/ -¶{{end}} - -{{Include "../api/templates/vulkan_common.tmpl"}} -{{Global "clang-format" (Strings "clang-format" "-style=file")}} -{{Macro "DefineGlobals" $}} -{{$ | Macro "api_gen.h" | Format (Global "clang-format") | Write "api_gen.h" }} -{{$ | Macro "api_gen.cpp" | Format (Global "clang-format") | Write "api_gen.cpp"}} -{{$ | Macro "driver_gen.h" | Format (Global "clang-format") | Write "driver_gen.h"}} -{{$ | Macro "driver_gen.cpp" | Format (Global "clang-format") | Write "driver_gen.cpp"}} - -{{/* -------------------------------------------------------------------------------- - api_gen.h -------------------------------------------------------------------------------- -*/}} -{{define "api_gen.h"}} -{{Macro "Copyright"}} -¶ -// WARNING: This file is generated. See ../README.md for instructions. -¶ -#ifndef LIBVULKAN_API_GEN_H -#define LIBVULKAN_API_GEN_H -¶ -#include <vulkan/vulkan.h> -¶ -#include <bitset> -¶ -#include "driver_gen.h" -¶ -namespace vulkan {« -namespace api {« -¶ -struct InstanceDispatchTable { - // clang-format off - {{range $f := AllCommands $}} - {{if (Macro "api.IsInstanceDispatchTableEntry" $f)}} - {{Macro "C++.DeclareTableEntry" $f}}; - {{end}} - {{end}} - // clang-format on -}; -¶ -struct DeviceDispatchTable { - // clang-format off - {{range $f := AllCommands $}} - {{if (Macro "api.IsDeviceDispatchTableEntry" $f)}} - {{Macro "C++.DeclareTableEntry" $f}}; - {{end}} - {{end}} - // clang-format on -}; -¶ -bool InitDispatchTable( - VkInstance instance, - PFN_vkGetInstanceProcAddr get_proc, - const std::bitset<driver::ProcHook::EXTENSION_COUNT> &extensions); -bool InitDispatchTable( - VkDevice dev, - PFN_vkGetDeviceProcAddr get_proc, - const std::bitset<driver::ProcHook::EXTENSION_COUNT> &extensions); -¶ -»} // namespace api -»} // namespace vulkan -¶ -#endif // LIBVULKAN_API_GEN_H -¶{{end}} - - -{{/* -------------------------------------------------------------------------------- - api_gen.cpp -------------------------------------------------------------------------------- -*/}} -{{define "api_gen.cpp"}} -{{Macro "Copyright"}} -¶ -// WARNING: This file is generated. See ../README.md for instructions. -¶ -#include <log/log.h> -#include <string.h> -¶ -#include <algorithm> -¶ -// to catch mismatches between vulkan.h and this file -#undef VK_NO_PROTOTYPES -#include "api.h" -¶ -namespace vulkan {« -namespace api {« -¶ -{{Macro "C++.DefineInitProcMacro" "dispatch"}} -¶ -{{Macro "api.C++.DefineInitProcExtMacro"}} -¶ -namespace {« -¶ -// clang-format off -¶ -{{range $f := AllCommands $}} - {{Macro "api.C++.DefineExtensionStub" $f}} -{{end}} -// clang-format on -¶ -»} // anonymous -¶ -bool InitDispatchTable( - VkInstance instance, - PFN_vkGetInstanceProcAddr get_proc, - const std::bitset<driver::ProcHook::EXTENSION_COUNT> &extensions) { - auto& data = GetData(instance); - bool success = true; - ¶ - // clang-format off - {{range $f := AllCommands $}} - {{if (Macro "api.IsInstanceDispatchTableEntry" $f)}} - {{Macro "C++.InitProc" $f}} - {{end}} - {{end}} - // clang-format on - ¶ - return success; -} -¶ -bool InitDispatchTable( - VkDevice dev, - PFN_vkGetDeviceProcAddr get_proc, - const std::bitset<driver::ProcHook::EXTENSION_COUNT> &extensions) { - auto& data = GetData(dev); - bool success = true; - ¶ - // clang-format off - {{range $f := AllCommands $}} - {{if (Macro "api.IsDeviceDispatchTableEntry" $f)}} - {{Macro "C++.InitProc" $f}} - {{end}} - {{end}} - // clang-format on - ¶ - return success; -} -¶ -// clang-format off -¶ -namespace {« -¶ -// forward declarations needed by GetInstanceProcAddr and GetDeviceProcAddr -{{range $f := AllCommands $}} - {{if and (Macro "IsFunctionExported" $f) (not (Macro "api.IsIntercepted" $f))}} - VKAPI_ATTR {{Node "Type" $f.Return}} {{Macro "BaseName" $f}}({{Macro "Parameters" $f}}); - {{end}} -{{end}} -¶ -{{range $f := AllCommands $}} - {{if and (Macro "IsFunctionExported" $f) (not (Macro "api.IsIntercepted" $f))}} - VKAPI_ATTR {{Node "Type" $f.Return}} {{Macro "BaseName" $f}}({{Macro "Parameters" $f}}) { - {{ if eq $f.Name "vkGetInstanceProcAddr"}} - {{Macro "api.C++.InterceptInstanceProcAddr" $}} - {{else if eq $f.Name "vkGetDeviceProcAddr"}} - {{Macro "api.C++.InterceptDeviceProcAddr" $}} - {{end}} - - {{Macro "api.C++.Dispatch" $f}} - } - ¶ - {{end}} -{{end}} -¶ -»} // anonymous namespace -¶ -// clang-format on -¶ -»} // namespace api -»} // namespace vulkan -¶ -// clang-format off -¶ -{{range $f := AllCommands $}} - {{if (Macro "IsFunctionExported" $f)}} - __attribute__((visibility("default"))) - VKAPI_ATTR {{Node "Type" $f.Return}} {{$f.Name}}({{Macro "Parameters" $f}}) { - {{if not (IsVoid $f.Return.Type)}}return §{{end}} - vulkan::api::{{Macro "BaseName" $f}}({{Macro "Arguments" $f}}); - } - ¶ - {{end}} -{{end}} -¶ -// clang-format on -¶{{end}} - - -{{/* -------------------------------------------------------------------------------- - driver_gen.h -------------------------------------------------------------------------------- -*/}} -{{define "driver_gen.h"}} -{{Macro "Copyright"}} -¶ -// WARNING: This file is generated. See ../README.md for instructions. -¶ -#ifndef LIBVULKAN_DRIVER_GEN_H -#define LIBVULKAN_DRIVER_GEN_H -¶ -#include <vulkan/vk_android_native_buffer.h> -#include <vulkan/vulkan.h> -¶ -#include <bitset> -¶ -namespace vulkan {« -namespace driver {« -¶ -{{Macro "driver.C++.DefineProcHookType"}} -¶ -struct InstanceDriverTable { - // clang-format off - {{range $f := AllCommands $}} - {{if (Macro "driver.IsInstanceDriverTableEntry" $f)}} - {{Macro "C++.DeclareTableEntry" $f}}; - {{end}} - {{end}} - // clang-format on -}; -¶ -struct DeviceDriverTable { - // clang-format off - {{range $f := AllCommands $}} - {{if (Macro "driver.IsDeviceDriverTableEntry" $f)}} - {{Macro "C++.DeclareTableEntry" $f}}; - {{end}} - {{end}} - // clang-format on -}; -¶ -const ProcHook* GetProcHook(const char* name); -ProcHook::Extension GetProcHookExtension(const char* name); -¶ -bool InitDriverTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc, - const std::bitset<ProcHook::EXTENSION_COUNT> &extensions); -bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc, - const std::bitset<ProcHook::EXTENSION_COUNT> &extensions); -¶ -»} // namespace driver -»} // namespace vulkan -¶ -#endif // LIBVULKAN_DRIVER_TABLE_H -¶{{end}} - - -{{/* -------------------------------------------------------------------------------- - driver_gen.cpp -------------------------------------------------------------------------------- -*/}} -{{define "driver_gen.cpp"}} -{{Macro "Copyright"}} -¶ -// WARNING: This file is generated. See ../README.md for instructions. -¶ -#include <log/log.h> -#include <string.h> -¶ -#include <algorithm> -¶ -#include "driver.h" -¶ -namespace vulkan {« -namespace driver {« -¶ -namespace {« -¶ -// clang-format off -¶ -{{range $f := AllCommands $}} - {{Macro "driver.C++.DefineProcHookStub" $f}} -{{end}} -// clang-format on -¶ -const ProcHook g_proc_hooks[] = { - // clang-format off - {{range $f := SortBy (AllCommands $) "FunctionName"}} - {{if (Macro "driver.IsIntercepted" $f)}} - {{ if (Macro "IsGloballyDispatched" $f)}} - {{Macro "driver.C++.DefineGlobalProcHook" $f}} - {{else if (Macro "IsInstanceDispatched" $f)}} - {{Macro "driver.C++.DefineInstanceProcHook" $f}} - {{else if (Macro "IsDeviceDispatched" $f)}} - {{Macro "driver.C++.DefineDeviceProcHook" $f}} - {{end}} - {{end}} - {{end}} - // clang-format on -}; -¶ -»} // anonymous -¶ -const ProcHook* GetProcHook(const char* name) { - const auto& begin = g_proc_hooks; - const auto& end = g_proc_hooks + - sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]); - const auto hook = std::lower_bound(begin, end, name, - [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; }); - return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr; -} -¶ -ProcHook::Extension GetProcHookExtension(const char* name) { - {{$exts := Strings (Macro "driver.KnownExtensions") | SplitOn "\n"}} - // clang-format off - {{range $e := $exts}} - if (strcmp(name, "{{$e}}") == 0) return ProcHook::{{TrimPrefix "VK_" $e}}; - {{end}} - // clang-format on - return ProcHook::EXTENSION_UNKNOWN; -} -¶ -{{Macro "C++.DefineInitProcMacro" "driver"}} -¶ -{{Macro "driver.C++.DefineInitProcExtMacro"}} -¶ -bool InitDriverTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc, - const std::bitset<ProcHook::EXTENSION_COUNT> &extensions) -{ - auto& data = GetData(instance); - bool success = true; - ¶ - // clang-format off - {{range $f := AllCommands $}} - {{if (Macro "driver.IsInstanceDriverTableEntry" $f)}} - {{Macro "C++.InitProc" $f}} - {{end}} - {{end}} - // clang-format on - ¶ - return success; -} -¶ -bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc, - const std::bitset<ProcHook::EXTENSION_COUNT> &extensions) -{ - auto& data = GetData(dev); - bool success = true; - ¶ - // clang-format off - {{range $f := AllCommands $}} - {{if (Macro "driver.IsDeviceDriverTableEntry" $f)}} - {{Macro "C++.InitProc" $f}} - {{end}} - {{end}} - // clang-format on - ¶ - return success; -} -¶ -»} // namespace driver -»} // namespace vulkan -¶ -// clang-format on -¶{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits a declaration of a dispatch/driver table entry. ------------------------------------------------------------------------------- -*/}} -{{define "C++.DeclareTableEntry"}} - {{AssertType $ "Function"}} - - {{Macro "FunctionPtrName" $}} {{Macro "BaseName" $}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits INIT_PROC macro. -------------------------------------------------------------------------------- -*/}} -{{define "C++.DefineInitProcMacro"}} - #define UNLIKELY(expr) __builtin_expect((expr), 0) - ¶ - #define INIT_PROC(required, obj, proc) do { \ - data.{{$}}.proc = reinterpret_cast<PFN_vk ## proc>( \ - get_proc(obj, "vk" # proc)); \ - if (UNLIKELY(required && !data.{{$}}.proc)) { \ - ALOGE("missing " # obj " proc: vk" # proc); \ - success = false; \ - } \ - } while(0) -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits code to invoke INIT_PROC or INIT_PROC_EXT. -------------------------------------------------------------------------------- -*/}} -{{define "C++.InitProc"}} - {{AssertType $ "Function"}} - - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - INIT_PROC_EXT({{Macro "BaseName" $ext}}, § - {{else}} - INIT_PROC(§ - {{end}} - - {{if GetAnnotation $ "optional"}}false{{else if GetAnnotation $ "vulkan1_1"}}false{{else}}true{{end}}, § - - {{if (Macro "IsInstanceDispatched" $)}} - instance, § - {{else}} - dev, § - {{end}} - - {{Macro "BaseName" $}}); -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits true if a function is exported and instance-dispatched. ------------------------------------------------------------------------------- -*/}} -{{define "api.IsInstanceDispatchTableEntry"}} - {{AssertType $ "Function"}} - - {{if and (Macro "IsFunctionExported" $) (Macro "IsInstanceDispatched" $)}} - {{/* deprecated and unused internally */}} - {{if not (eq $.Name "vkEnumerateDeviceLayerProperties")}} - true - {{end}} - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits true if a function is exported and device-dispatched. ------------------------------------------------------------------------------- -*/}} -{{define "api.IsDeviceDispatchTableEntry"}} - {{AssertType $ "Function"}} - - {{if and (Macro "IsFunctionExported" $) (Macro "IsDeviceDispatched" $)}} - true - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits true if a function is intercepted by vulkan::api. ------------------------------------------------------------------------------- -*/}} -{{define "api.IsIntercepted"}} - {{AssertType $ "Function"}} - - {{if (Macro "IsFunctionSupported" $)}} - {{/* Global functions cannot be dispatched at all */}} - {{ if (Macro "IsGloballyDispatched" $)}}true - - {{/* VkPhysicalDevice functions that manage device layers */}} - {{else if eq $.Name "vkCreateDevice"}}true - {{else if eq $.Name "vkEnumerateDeviceLayerProperties"}}true - {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true - - {{/* Destroy functions of dispatchable objects */}} - {{else if eq $.Name "vkDestroyInstance"}}true - {{else if eq $.Name "vkDestroyDevice"}}true - - {{end}} - {{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits INIT_PROC_EXT macro for vulkan::api. -------------------------------------------------------------------------------- -*/}} -{{define "api.C++.DefineInitProcExtMacro"}} - // Exported extension functions may be invoked even when their extensions - // are disabled. Dispatch to stubs when that happens. - #define INIT_PROC_EXT(ext, required, obj, proc) do { \ - if (extensions[driver::ProcHook::ext]) \ - INIT_PROC(required, obj, proc); \ - else \ - data.dispatch.proc = disabled ## proc; \ - } while(0) -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a stub for an exported extension function. -------------------------------------------------------------------------------- -*/}} -{{define "api.C++.DefineExtensionStub"}} - {{AssertType $ "Function"}} - - {{$ext := GetAnnotation $ "extension"}} - {{if and $ext (Macro "IsFunctionExported" $)}} - {{$ext_name := index $ext.Arguments 0}} - - {{$base := (Macro "BaseName" $)}} - - {{$p0 := (index $.CallParameters 0)}} - {{$ptail := (Tail 1 $.CallParameters)}} - - {{$first_type := (Macro "Parameter" $p0)}} - {{$tail_types := (ForEach $ptail "ParameterType" | JoinWith ", ")}} - - VKAPI_ATTR {{Node "Type" $.Return}} disabled{{$base}}({{$first_type}}, {{$tail_types}}) { - driver::Logger({{$p0.Name}}).Err({{$p0.Name}}, § - "{{$ext_name}} not enabled. Exported {{$.Name}} not executed."); - {{if not (IsVoid $.Return.Type)}}return VK_SUCCESS;{{end}} - } - ¶ - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits code for vkGetInstanceProcAddr for function interception. ------------------------------------------------------------------------------- -*/}} -{{define "api.C++.InterceptInstanceProcAddr"}} - {{AssertType $ "API"}} - - // global functions - if (instance == VK_NULL_HANDLE) { - {{range $f := AllCommands $}} - {{if (Macro "IsGloballyDispatched" $f)}} - if (strcmp(pName, "{{$f.Name}}") == 0) return § - reinterpret_cast<PFN_vkVoidFunction>({{Macro "BaseName" $f}}); - {{end}} - {{end}} - ¶ - ALOGE("invalid vkGetInstanceProcAddr(VK_NULL_HANDLE, \"%s\") call", pName); - return nullptr; - } - ¶ - static const struct Hook { - const char* name; - PFN_vkVoidFunction proc; - } hooks[] = { - {{range $f := SortBy (AllCommands $) "FunctionName"}} - {{if (Macro "IsFunctionExported" $f)}} - {{/* hide global functions */}} - {{if (Macro "IsGloballyDispatched" $f)}} - { "{{$f.Name}}", nullptr }, - - {{/* redirect intercepted functions */}} - {{else if (Macro "api.IsIntercepted" $f)}} - { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§ - {{Macro "BaseName" $f}}) }, - - {{/* redirect vkGetInstanceProcAddr to itself */}} - {{else if eq $f.Name "vkGetInstanceProcAddr"}} - { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "BaseName" $f}}) }, - - {{/* redirect device functions to themselves as a workaround for - layers that do not intercept in their vkGetInstanceProcAddr */}} - {{else if (Macro "IsDeviceDispatched" $f)}} - { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "BaseName" $f}}) }, - - {{end}} - {{end}} - {{end}} - }; - // clang-format on - constexpr size_t count = sizeof(hooks) / sizeof(hooks[0]); - auto hook = std::lower_bound( - hooks, hooks + count, pName, - [](const Hook& h, const char* n) { return strcmp(h.name, n) < 0; }); - if (hook < hooks + count && strcmp(hook->name, pName) == 0) { - if (!hook->proc) { - vulkan::driver::Logger(instance).Err( - instance, "invalid vkGetInstanceProcAddr(%p, \"%s\") call", - instance, pName); - } - return hook->proc; - } - // clang-format off - ¶ -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits code for vkGetDeviceProcAddr for function interception. ------------------------------------------------------------------------------- -*/}} -{{define "api.C++.InterceptDeviceProcAddr"}} - {{AssertType $ "API"}} - - if (device == VK_NULL_HANDLE) { - ALOGE("invalid vkGetDeviceProcAddr(VK_NULL_HANDLE, ...) call"); - return nullptr; - } - ¶ - static const char* const known_non_device_names[] = { - {{range $f := SortBy (AllCommands $) "FunctionName"}} - {{if (Macro "IsFunctionSupported" $f)}} - {{if not (Macro "IsDeviceDispatched" $f)}} - "{{$f.Name}}", - {{end}} - {{end}} - {{end}} - }; - // clang-format on - constexpr size_t count = sizeof(known_non_device_names) / - sizeof(known_non_device_names[0]); - if (!pName || - std::binary_search( - known_non_device_names, known_non_device_names + count, pName, - [](const char* a, const char* b) { return (strcmp(a, b) < 0); })) { - vulkan::driver::Logger(device).Err(§ - device, "invalid vkGetDeviceProcAddr(%p, \"%s\") call", device,§ - (pName) ? pName : "(null)"); - return nullptr; - } - // clang-format off - ¶ - {{range $f := AllCommands $}} - {{if (Macro "IsDeviceDispatched" $f)}} - {{ if (Macro "api.IsIntercepted" $f)}} - if (strcmp(pName, "{{$f.Name}}") == 0) return § - reinterpret_cast<PFN_vkVoidFunction>(§ - {{Macro "BaseName" $f}}); - {{else if eq $f.Name "vkGetDeviceProcAddr"}} - if (strcmp(pName, "{{$f.Name}}") == 0) return § - reinterpret_cast<PFN_vkVoidFunction>(§ - {{Macro "BaseName" $f}}); - {{end}} - {{end}} - {{end}} - ¶ -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits code to dispatch a function. ------------------------------------------------------------------------------- -*/}} -{{define "api.C++.Dispatch"}} - {{AssertType $ "Function"}} - {{if (Macro "api.IsIntercepted" $)}} - {{Error "$.Name should not be generated"}} - {{end}} - - {{if not (IsVoid $.Return.Type)}}return §{{end}} - - {{$p0 := index $.CallParameters 0}} - GetData({{$p0.Name}}).dispatch.§ - {{Macro "BaseName" $}}({{Macro "Arguments" $}}); -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits a list of extensions intercepted by vulkan::driver. ------------------------------------------------------------------------------- -*/}} -{{define "driver.InterceptedExtensions"}} -VK_ANDROID_native_buffer -VK_EXT_debug_report -VK_EXT_hdr_metadata -VK_EXT_swapchain_colorspace -VK_GOOGLE_display_timing -VK_KHR_android_surface -VK_KHR_incremental_present -VK_KHR_shared_presentable_image -VK_KHR_surface -VK_KHR_swapchain -VK_KHR_get_surface_capabilities2 -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits a list of extensions known to vulkan::driver. ------------------------------------------------------------------------------- -*/}} -{{define "driver.KnownExtensions"}} -{{Macro "driver.InterceptedExtensions"}} -VK_KHR_get_physical_device_properties2 -VK_ANDROID_external_memory_android_hardware_buffer -VK_KHR_bind_memory2 -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits true if an extension is intercepted by vulkan::driver. ------------------------------------------------------------------------------- -*/}} -{{define "driver.IsExtensionIntercepted"}} - {{$ext_name := index $.Arguments 0}} - {{$filters := Strings (Macro "driver.InterceptedExtensions") | SplitOn "\n"}} - - {{range $f := $filters}} - {{if eq $ext_name $f}}true{{end}} - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits true if a function is intercepted by vulkan::driver. ------------------------------------------------------------------------------- -*/}} -{{define "driver.IsIntercepted"}} - {{AssertType $ "Function"}} - - {{if (Macro "IsFunctionSupported" $)}} - {{/* Create functions of dispatchable objects */}} - {{ if eq $.Name "vkCreateInstance"}}true - {{else if eq $.Name "vkCreateDevice"}}true - {{else if eq $.Name "vkEnumeratePhysicalDevices"}}true - {{else if eq $.Name "vkEnumeratePhysicalDeviceGroups"}}true - {{else if eq $.Name "vkGetDeviceQueue"}}true - {{else if eq $.Name "vkGetDeviceQueue2"}}true - {{else if eq $.Name "vkAllocateCommandBuffers"}}true - - {{/* Destroy functions of dispatchable objects */}} - {{else if eq $.Name "vkDestroyInstance"}}true - {{else if eq $.Name "vkDestroyDevice"}}true - - {{/* Enumeration of extensions */}} - {{else if eq $.Name "vkEnumerateInstanceExtensionProperties"}}true - {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true - - {{else if eq $.Name "vkGetInstanceProcAddr"}}true - {{else if eq $.Name "vkGetDeviceProcAddr"}}true - - {{/* VK_KHR_swapchain v69 requirement */}} - {{else if eq $.Name "vkBindImageMemory2"}}true - {{else if eq $.Name "vkBindImageMemory2KHR"}}true - {{end}} - - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - {{Macro "driver.IsExtensionIntercepted" $ext}} - {{end}} - - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits true if a function needs a ProcHook stub. ------------------------------------------------------------------------------- -*/}} -{{define "driver.NeedProcHookStub"}} - {{AssertType $ "Function"}} - - {{if and (Macro "driver.IsIntercepted" $) (Macro "IsDeviceDispatched" $)}} - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - {{if not (Macro "IsExtensionInternal" $ext)}}true{{end}} - {{end}} - {{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits definition of struct ProcHook. -------------------------------------------------------------------------------- -*/}} -{{define "driver.C++.DefineProcHookType"}} - struct ProcHook { - enum Type { - GLOBAL, - INSTANCE, - DEVICE, - }; - - enum Extension { - {{$exts := Strings (Macro "driver.KnownExtensions") | SplitOn "\n"}} - {{range $e := $exts}} - {{TrimPrefix "VK_" $e}}, - {{end}} - ¶ - EXTENSION_CORE, // valid bit - EXTENSION_COUNT, - EXTENSION_UNKNOWN, - }; - ¶ - const char* name; - Type type; - Extension extension; - ¶ - PFN_vkVoidFunction proc; - PFN_vkVoidFunction checked_proc; // always nullptr for non-device hooks - }; -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits INIT_PROC_EXT macro for vulkan::driver. -------------------------------------------------------------------------------- -*/}} -{{define "driver.C++.DefineInitProcExtMacro"}} - #define INIT_PROC_EXT(ext, required, obj, proc) do { \ - if (extensions[ProcHook::ext]) \ - INIT_PROC(required, obj, proc); \ - } while(0) -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a stub for ProcHook::checked_proc. -------------------------------------------------------------------------------- -*/}} -{{define "driver.C++.DefineProcHookStub"}} - {{AssertType $ "Function"}} - - {{if (Macro "driver.NeedProcHookStub" $)}} - {{$ext := GetAnnotation $ "extension"}} - {{$ext_name := index $ext.Arguments 0}} - - {{$base := (Macro "BaseName" $)}} - - VKAPI_ATTR {{Node "Type" $.Return}} checked{{$base}}({{Macro "Parameters" $}}) { - {{$p0 := index $.CallParameters 0}} - {{$ext_hook := Strings ("ProcHook::") (Macro "BaseName" $ext)}} - - if (GetData({{$p0.Name}}).hook_extensions[{{$ext_hook}}]) { - {{if not (IsVoid $.Return.Type)}}return §{{end}} - {{$base}}({{Macro "Arguments" $}}); - } else { - Logger({{$p0.Name}}).Err({{$p0.Name}}, "{{$ext_name}} not enabled. {{$.Name}} not executed."); - {{if not (IsVoid $.Return.Type)}}return VK_SUCCESS;{{end}} - } - } - ¶ - {{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits definition of a global ProcHook. -------------------------------------------------------------------------------- -*/}} -{{define "driver.C++.DefineGlobalProcHook"}} - {{AssertType $ "Function"}} - - {{$base := (Macro "BaseName" $)}} - - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - {{Error "invalid global extension"}} - {{end}} - - { - "{{$.Name}}", - ProcHook::GLOBAL, - ProcHook::EXTENSION_CORE, - reinterpret_cast<PFN_vkVoidFunction>({{$base}}), - nullptr, - }, -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits definition of an instance ProcHook. -------------------------------------------------------------------------------- -*/}} -{{define "driver.C++.DefineInstanceProcHook"}} - {{AssertType $ "Function"}} - - {{$base := (Macro "BaseName" $)}} - - { - "{{$.Name}}", - ProcHook::INSTANCE, - - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - ProcHook::{{Macro "BaseName" $ext}}, - - {{if (Macro "IsExtensionInternal" $ext)}} - nullptr, - nullptr, - {{else}} - reinterpret_cast<PFN_vkVoidFunction>({{$base}}), - nullptr, - {{end}} - {{else}} - ProcHook::EXTENSION_CORE, - reinterpret_cast<PFN_vkVoidFunction>({{$base}}), - nullptr, - {{end}} - }, -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits definition of a device ProcHook. -------------------------------------------------------------------------------- -*/}} -{{define "driver.C++.DefineDeviceProcHook"}} - {{AssertType $ "Function"}} - - {{$base := (Macro "BaseName" $)}} - - { - "{{$.Name}}", - ProcHook::DEVICE, - - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - ProcHook::{{Macro "BaseName" $ext}}, - - {{if (Macro "IsExtensionInternal" $ext)}} - nullptr, - nullptr, - {{else}} - reinterpret_cast<PFN_vkVoidFunction>({{$base}}), - reinterpret_cast<PFN_vkVoidFunction>(checked{{$base}}), - {{end}} - {{else}} - ProcHook::EXTENSION_CORE, - reinterpret_cast<PFN_vkVoidFunction>({{$base}}), - nullptr, - {{end}} - }, -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits true if a function is needed by vulkan::driver. -------------------------------------------------------------------------------- -*/}} -{{define "driver.IsDriverTableEntry"}} - {{AssertType $ "Function"}} - - {{if (Macro "IsFunctionSupported" $)}} - {{/* Create functions of dispatchable objects */}} - {{ if eq $.Name "vkCreateDevice"}}true - {{else if eq $.Name "vkGetDeviceQueue"}}true - {{else if eq $.Name "vkGetDeviceQueue2"}}true - {{else if eq $.Name "vkAllocateCommandBuffers"}}true - - {{/* Destroy functions of dispatchable objects */}} - {{else if eq $.Name "vkDestroyInstance"}}true - {{else if eq $.Name "vkDestroyDevice"}}true - - {{/* Enumeration of extensions */}} - {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true - - {{/* We cache physical devices in loader.cpp */}} - {{else if eq $.Name "vkEnumeratePhysicalDevices"}}true - {{else if eq $.Name "vkEnumeratePhysicalDeviceGroups"}}true - - {{else if eq $.Name "vkGetInstanceProcAddr"}}true - {{else if eq $.Name "vkGetDeviceProcAddr"}}true - - {{/* VK_KHR_swapchain->VK_ANDROID_native_buffer translation */}} - {{else if eq $.Name "vkCreateImage"}}true - {{else if eq $.Name "vkDestroyImage"}}true - - {{else if eq $.Name "vkGetPhysicalDeviceProperties"}}true - {{else if eq $.Name "vkGetPhysicalDeviceProperties2"}}true - {{else if eq $.Name "vkGetPhysicalDeviceProperties2KHR"}}true - - {{/* VK_KHR_swapchain v69 requirement */}} - {{else if eq $.Name "vkBindImageMemory2"}}true - {{else if eq $.Name "vkBindImageMemory2KHR"}}true - {{end}} - - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - {{$ext_name := index $ext.Arguments 0}} - {{ if eq $ext_name "VK_ANDROID_native_buffer"}}true - {{else if eq $ext_name "VK_EXT_debug_report"}}true - {{end}} - {{end}} - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits true if an instance-dispatched function is needed by vulkan::driver. ------------------------------------------------------------------------------- -*/}} -{{define "driver.IsInstanceDriverTableEntry"}} - {{AssertType $ "Function"}} - - {{if and (Macro "driver.IsDriverTableEntry" $) (Macro "IsInstanceDispatched" $)}} - true - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits true if a device-dispatched function is needed by vulkan::driver. ------------------------------------------------------------------------------- -*/}} -{{define "driver.IsDeviceDriverTableEntry"}} - {{AssertType $ "Function"}} - - {{if and (Macro "driver.IsDriverTableEntry" $) (Macro "IsDeviceDispatched" $)}} - true - {{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a function/extension name without the "vk"/"VK_" prefix. -------------------------------------------------------------------------------- -*/}} -{{define "BaseName"}} - {{ if IsFunction $}}{{TrimPrefix "vk" $.Name}} - {{else if eq $.Name "extension"}}{{TrimPrefix "VK_" (index $.Arguments 0)}} - {{else}}{{Error "invalid use of BaseName"}} - {{end}} -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a comma-separated list of C parameter names for the given command. -------------------------------------------------------------------------------- -*/}} -{{define "Arguments"}} - {{AssertType $ "Function"}} - - {{ForEach $.CallParameters "ParameterName" | JoinWith ", "}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- ------------------------------------------------------------------------------- -*/}} -{{define "IsGloballyDispatched"}} - {{AssertType $ "Function"}} - {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Global")}} - true - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emit "true" for supported functions that undergo table dispatch. Only global - functions and functions handled in the loader top without calling into - lower layers are not dispatched. ------------------------------------------------------------------------------- -*/}} -{{define "IsInstanceDispatched"}} - {{AssertType $ "Function"}} - {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Instance")}} - true - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emit "true" for supported functions that can have device-specific dispatch. ------------------------------------------------------------------------------- -*/}} -{{define "IsDeviceDispatched"}} - {{AssertType $ "Function"}} - {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Device")}} - true - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emit "true" if a function is core or from a supportable extension. ------------------------------------------------------------------------------- -*/}} -{{define "IsFunctionSupported"}} - {{AssertType $ "Function"}} - {{if not (GetAnnotation $ "pfn")}} - {{$ext := GetAnnotation $ "extension"}} - {{if not $ext}}true - {{else if not (Macro "IsExtensionBlacklisted" $ext)}}true - {{end}} - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Decides whether a function should be exported from the Android Vulkan - library. Functions in the core API and in loader extensions are exported. ------------------------------------------------------------------------------- -*/}} -{{define "IsFunctionExported"}} - {{AssertType $ "Function"}} - - {{if (Macro "IsFunctionSupported" $)}} - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - {{Macro "IsExtensionExported" $ext}} - {{else}} - true - {{end}} - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emit "true" if an extension is unsupportable on Android. ------------------------------------------------------------------------------- -*/}} -{{define "IsExtensionBlacklisted"}} - {{$ext := index $.Arguments 0}} - {{ if eq $ext "VK_KHR_display"}}true - {{else if eq $ext "VK_KHR_display_swapchain"}}true - {{else if eq $ext "VK_KHR_mir_surface"}}true - {{else if eq $ext "VK_KHR_xcb_surface"}}true - {{else if eq $ext "VK_KHR_xlib_surface"}}true - {{else if eq $ext "VK_KHR_wayland_surface"}}true - {{else if eq $ext "VK_KHR_win32_surface"}}true - {{else if eq $ext "VK_KHR_external_memory_win32"}}true - {{else if eq $ext "VK_KHR_win32_keyed_mutex"}}true - {{else if eq $ext "VK_KHR_external_semaphore_win32"}}true - {{else if eq $ext "VK_KHR_external_fence_win32"}}true - {{else if eq $ext "VK_EXT_acquire_xlib_display"}}true - {{else if eq $ext "VK_EXT_direct_mode_display"}}true - {{else if eq $ext "VK_EXT_display_surface_counter"}}true - {{else if eq $ext "VK_EXT_display_control"}}true - {{else if eq $ext "VK_FUCHSIA_imagepipe_surface"}}true - {{else if eq $ext "VK_MVK_ios_surface"}}true - {{else if eq $ext "VK_MVK_macos_surface"}}true - {{else if eq $ext "VK_NN_vi_surface"}}true - {{else if eq $ext "VK_NV_external_memory_win32"}}true - {{else if eq $ext "VK_NV_win32_keyed_mutex"}}true - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Reports whether an extension has functions exported by the loader. - E.g. applications can directly link to an extension function. ------------------------------------------------------------------------------- -*/}} -{{define "IsExtensionExported"}} - {{$ext := index $.Arguments 0}} - {{ if eq $ext "VK_KHR_surface"}}true - {{else if eq $ext "VK_KHR_swapchain"}}true - {{else if eq $ext "VK_KHR_android_surface"}}true - {{else if eq $ext "VK_ANDROID_external_memory_android_hardware_buffer"}}true - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Reports whether an extension is internal to the loader and drivers, - so the loader should not enumerate it. ------------------------------------------------------------------------------- -*/}} -{{define "IsExtensionInternal"}} - {{$ext := index $.Arguments 0}} - {{ if eq $ext "VK_ANDROID_native_buffer"}}true - {{end}} -{{end}} diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 7020be1eda..3495861d35 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -74,6 +74,15 @@ VKAPI_ATTR VkResult checkedQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR } } +VKAPI_ATTR VkResult checkedBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { + if (GetData(device).hook_extensions[ProcHook::KHR_bind_memory2]) { + return BindImageMemory2KHR(device, bindInfoCount, pBindInfos); + } else { + Logger(device).Err(device, "VK_KHR_bind_memory2 not enabled. vkBindImageMemory2KHR not executed."); + return VK_SUCCESS; + } +} + VKAPI_ATTR VkResult checkedGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) { return GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); @@ -101,24 +110,6 @@ VKAPI_ATTR VkResult checkedAcquireNextImage2KHR(VkDevice device, const VkAcquire } } -VKAPI_ATTR VkResult checkedGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { - if (GetData(device).hook_extensions[ProcHook::GOOGLE_display_timing]) { - return GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); - } else { - Logger(device).Err(device, "VK_GOOGLE_display_timing not enabled. vkGetRefreshCycleDurationGOOGLE not executed."); - return VK_SUCCESS; - } -} - -VKAPI_ATTR VkResult checkedGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { - if (GetData(device).hook_extensions[ProcHook::GOOGLE_display_timing]) { - return GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); - } else { - Logger(device).Err(device, "VK_GOOGLE_display_timing not enabled. vkGetPastPresentationTimingGOOGLE not executed."); - return VK_SUCCESS; - } -} - VKAPI_ATTR void checkedSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { if (GetData(device).hook_extensions[ProcHook::EXT_hdr_metadata]) { SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); @@ -136,11 +127,20 @@ VKAPI_ATTR VkResult checkedGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR } } -VKAPI_ATTR VkResult checkedBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos) { - if (GetData(device).hook_extensions[ProcHook::KHR_bind_memory2]) { - return BindImageMemory2KHR(device, bindInfoCount, pBindInfos); +VKAPI_ATTR VkResult checkedGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { + if (GetData(device).hook_extensions[ProcHook::GOOGLE_display_timing]) { + return GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); } else { - Logger(device).Err(device, "VK_KHR_bind_memory2 not enabled. vkBindImageMemory2KHR not executed."); + Logger(device).Err(device, "VK_GOOGLE_display_timing not enabled. vkGetRefreshCycleDurationGOOGLE not executed."); + return VK_SUCCESS; + } +} + +VKAPI_ATTR VkResult checkedGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { + if (GetData(device).hook_extensions[ProcHook::GOOGLE_display_timing]) { + return GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); + } else { + Logger(device).Err(device, "VK_GOOGLE_display_timing not enabled. vkGetPastPresentationTimingGOOGLE not executed."); return VK_SUCCESS; } } @@ -516,12 +516,12 @@ bool InitDriverTable(VkInstance instance, INIT_PROC(true, instance, GetPhysicalDeviceProperties); INIT_PROC(true, instance, CreateDevice); INIT_PROC(true, instance, EnumerateDeviceExtensionProperties); - INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); - INIT_PROC(false, instance, GetPhysicalDeviceProperties2); INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT); INIT_PROC_EXT(EXT_debug_report, true, instance, DestroyDebugReportCallbackEXT); INIT_PROC_EXT(EXT_debug_report, true, instance, DebugReportMessageEXT); + INIT_PROC(false, instance, GetPhysicalDeviceProperties2); INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceProperties2KHR); + INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); // clang-format on return success; @@ -541,12 +541,12 @@ bool InitDriverTable(VkDevice dev, INIT_PROC(true, dev, DestroyImage); INIT_PROC(true, dev, AllocateCommandBuffers); INIT_PROC(false, dev, BindImageMemory2); + INIT_PROC_EXT(KHR_bind_memory2, true, dev, BindImageMemory2KHR); INIT_PROC(false, dev, GetDeviceQueue2); INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsageANDROID); - INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsage2ANDROID); INIT_PROC_EXT(ANDROID_native_buffer, true, dev, AcquireImageANDROID); INIT_PROC_EXT(ANDROID_native_buffer, true, dev, QueueSignalReleaseImageANDROID); - INIT_PROC_EXT(KHR_bind_memory2, true, dev, BindImageMemory2KHR); + INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsage2ANDROID); // clang-format on return success; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index c299549dae..79f070c72d 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -70,12 +70,12 @@ struct InstanceDriverTable { PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties; PFN_vkCreateDevice CreateDevice; PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties; - PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; - PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2; PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT; PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT; PFN_vkDebugReportMessageEXT DebugReportMessageEXT; + PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2; PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR; + PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; // clang-format on }; @@ -88,12 +88,12 @@ struct DeviceDriverTable { PFN_vkDestroyImage DestroyImage; PFN_vkAllocateCommandBuffers AllocateCommandBuffers; PFN_vkBindImageMemory2 BindImageMemory2; + PFN_vkBindImageMemory2KHR BindImageMemory2KHR; PFN_vkGetDeviceQueue2 GetDeviceQueue2; PFN_vkGetSwapchainGrallocUsageANDROID GetSwapchainGrallocUsageANDROID; - PFN_vkGetSwapchainGrallocUsage2ANDROID GetSwapchainGrallocUsage2ANDROID; PFN_vkAcquireImageANDROID AcquireImageANDROID; PFN_vkQueueSignalReleaseImageANDROID QueueSignalReleaseImageANDROID; - PFN_vkBindImageMemory2KHR BindImageMemory2KHR; + PFN_vkGetSwapchainGrallocUsage2ANDROID GetSwapchainGrallocUsage2ANDROID; // clang-format on }; diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index e5ac2de705..d60eaa7c21 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -370,9 +370,6 @@ uint32_t get_num_ready_timings(Swapchain& swapchain) { nullptr, //&first_composition_start_time, nullptr, //&last_composition_start_time, nullptr, //&composition_finish_time, - // TODO(ianelliott): Maybe ask if this one is - // supported, at startup time (since it may not be - // supported): &actual_present_time, nullptr, //&dequeue_ready_time, nullptr /*&reads_done_time*/); @@ -399,7 +396,6 @@ uint32_t get_num_ready_timings(Swapchain& swapchain) { return num_ready; } -// TODO(ianelliott): DEAL WITH RETURN VALUE (e.g. VK_INCOMPLETE)!!! void copy_ready_timings(Swapchain& swapchain, uint32_t* count, VkPastPresentationTimingGOOGLE* timings) { @@ -1773,6 +1769,10 @@ VkResult GetPastPresentationTimingGOOGLE( ATRACE_CALL(); Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle); + if (swapchain.surface.swapchain_handle != swapchain_handle) { + return VK_ERROR_OUT_OF_DATE_KHR; + } + ANativeWindow* window = swapchain.surface.window.get(); VkResult result = VK_SUCCESS; @@ -1783,8 +1783,15 @@ VkResult GetPastPresentationTimingGOOGLE( } if (timings) { - // TODO(ianelliott): plumb return value (e.g. VK_INCOMPLETE) + // Get the latest ready timing count before copying, since the copied + // timing info will be erased in copy_ready_timings function. + uint32_t n = get_num_ready_timings(swapchain); copy_ready_timings(swapchain, count, timings); + // Check the *count here against the recorded ready timing count, since + // *count can be overwritten per spec describes. + if (*count < n) { + result = VK_INCOMPLETE; + } } else { *count = get_num_ready_timings(swapchain); } diff --git a/vulkan/nulldrv/null_driver.tmpl b/vulkan/nulldrv/null_driver.tmpl deleted file mode 100644 index 0f5301595c..0000000000 --- a/vulkan/nulldrv/null_driver.tmpl +++ /dev/null @@ -1,211 +0,0 @@ -{{/* - * Copyright 2015 The Android Open Source Project - * - * 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. - */}} - -{{Include "../api/templates/vulkan_common.tmpl"}} -{{Global "clang-format" (Strings "clang-format" "-style=file")}} -{{Macro "DefineGlobals" $}} -{{$ | Macro "null_driver_gen.h" | Format (Global "clang-format") | Write "null_driver_gen.h" }} -{{$ | Macro "null_driver_gen.cpp" | Format (Global "clang-format") | Write "null_driver_gen.cpp"}} - - -{{/* -------------------------------------------------------------------------------- - null_driver_gen.h -------------------------------------------------------------------------------- -*/}} -{{define "null_driver_gen.h"}} -/* -•* Copyright 2015 The Android Open Source Project -•* -•* 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. -•*/ -¶ -// WARNING: This file is generated. See ../README.md for instructions. -¶ -#ifndef NULLDRV_NULL_DRIVER_H -#define NULLDRV_NULL_DRIVER_H 1 -¶ -#include <vulkan/vk_android_native_buffer.h> -#include <vulkan/vulkan.h> -¶ -namespace null_driver {« -¶ -PFN_vkVoidFunction GetGlobalProcAddr(const char* name); -PFN_vkVoidFunction GetInstanceProcAddr(const char* name); -¶ -// clang-format off - {{range $f := AllCommands $}} - {{if (Macro "IsDriverFunction" $f)}} -VKAPI_ATTR {{Node "Type" $f.Return}} {{Macro "BaseName" $f}}({{Macro "Parameters" $f}}); - {{end}} - {{end}} -VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage); -VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence); -VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd); -// clang-format on -¶ -»} // namespace null_driver -¶ -#endif // NULLDRV_NULL_DRIVER_H -¶{{end}} - - -{{/* -------------------------------------------------------------------------------- - null_driver_gen.cpp -------------------------------------------------------------------------------- -*/}} -{{define "null_driver_gen.cpp"}} -/* -•* Copyright 2015 The Android Open Source Project -•* -•* 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. -•*/ -¶ -// WARNING: This file is generated. See ../README.md for instructions. -¶ -#include <algorithm> -¶ -#include "null_driver_gen.h" -¶ -using namespace null_driver; -¶ -namespace { -¶ -struct NameProc { - const char* name; - PFN_vkVoidFunction proc; -}; -¶ -PFN_vkVoidFunction Lookup(const char* name, - const NameProc* begin, - const NameProc* end) { - const auto& entry = std::lower_bound( - begin, end, name, - [](const NameProc& e, const char* n) { return strcmp(e.name, n) < 0; }); - if (entry == end || strcmp(entry->name, name) != 0) - return nullptr; - return entry->proc; -} -¶ -template <size_t N> -PFN_vkVoidFunction Lookup(const char* name, const NameProc (&procs)[N]) { - return Lookup(name, procs, procs + N); -} -¶ -const NameProc kGlobalProcs[] = {« - // clang-format off - {{range $f := SortBy (AllCommands $) "FunctionName"}} - {{if and (Macro "IsDriverFunction" $f) (eq (Macro "Vtbl" $f) "Global")}} - {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§ - static_cast<{{Macro "FunctionPtrName" $f}}>(§ - {{Macro "BaseName" $f}}))}, - {{end}} - {{end}} - // clang-format on -»}; -¶ -const NameProc kInstanceProcs[] = {« - // clang-format off - {{range $f := SortBy (AllCommands $) "FunctionName"}} - {{if (Macro "IsDriverFunction" $f)}} - {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§ - static_cast<{{Macro "FunctionPtrName" $f}}>(§ - {{Macro "BaseName" $f}}))}, - {{end}} - {{end}} - // clang-format on -»}; -¶ -} // namespace -¶ -namespace null_driver { -¶ -PFN_vkVoidFunction GetGlobalProcAddr(const char* name) { - return Lookup(name, kGlobalProcs); -} -¶ -PFN_vkVoidFunction GetInstanceProcAddr(const char* name) {« - return Lookup(name, kInstanceProcs); -»} -¶ -} // namespace null_driver -¶ -{{end}} - - -{{/* -------------------------------------------------------------------------------- - Emits a function name without the "vk" prefix. -------------------------------------------------------------------------------- -*/}} -{{define "BaseName"}} - {{AssertType $ "Function"}} - {{TrimPrefix "vk" $.Name}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Emits 'true' if the API function is implemented by the driver. ------------------------------------------------------------------------------- -*/}} -{{define "IsDriverFunction"}} - {{AssertType $ "Function"}} - - {{if not (GetAnnotation $ "pfn")}} - {{$ext := GetAnnotation $ "extension"}} - {{if $ext}} - {{Macro "IsDriverExtension" $ext}} - {{else}} - true - {{end}} - {{end}} -{{end}} - - -{{/* ------------------------------------------------------------------------------- - Reports whether an extension is implemented by the driver. ------------------------------------------------------------------------------- -*/}} -{{define "IsDriverExtension"}} - {{$ext := index $.Arguments 0}} - {{ if eq $ext "VK_ANDROID_native_buffer"}}true - {{else if eq $ext "VK_EXT_debug_report"}}true - {{else if eq $ext "VK_KHR_get_physical_device_properties2"}}true - {{end}} -{{end}} diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp index b8d7d2b643..7c9b0c05c7 100644 --- a/vulkan/nulldrv/null_driver_gen.cpp +++ b/vulkan/nulldrv/null_driver_gen.cpp @@ -16,10 +16,10 @@ // WARNING: This file is generated. See ../README.md for instructions. -#include <algorithm> - #include "null_driver_gen.h" +#include <algorithm> + using namespace null_driver; namespace { diff --git a/vulkan/nulldrv/null_driver_gen.h b/vulkan/nulldrv/null_driver_gen.h index c6ad537cb8..70ef340bcf 100644 --- a/vulkan/nulldrv/null_driver_gen.h +++ b/vulkan/nulldrv/null_driver_gen.h @@ -41,6 +41,7 @@ VKAPI_ATTR void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevic VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); VKAPI_ATTR void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult EnumerateInstanceVersion(uint32_t* pApiVersion); VKAPI_ATTR VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties); VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); VKAPI_ATTR VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); @@ -165,48 +166,47 @@ VKAPI_ATTR void CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRender VKAPI_ATTR void CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents); VKAPI_ATTR void CmdEndRenderPass(VkCommandBuffer commandBuffer); VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -VKAPI_ATTR VkResult EnumerateInstanceVersion(uint32_t* pApiVersion); -VKAPI_ATTR VkResult BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -VKAPI_ATTR VkResult BindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); -VKAPI_ATTR void GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -VKAPI_ATTR void CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); -VKAPI_ATTR void CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -VKAPI_ATTR VkResult EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR VkResult CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +VKAPI_ATTR void DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); VKAPI_ATTR void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +VKAPI_ATTR void GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); VKAPI_ATTR void GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +VKAPI_ATTR void GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); VKAPI_ATTR void GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +VKAPI_ATTR void GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); VKAPI_ATTR void TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); -VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +VKAPI_ATTR VkResult EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +VKAPI_ATTR void GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +VKAPI_ATTR VkResult BindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +VKAPI_ATTR VkResult BindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +VKAPI_ATTR void CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); +VKAPI_ATTR void CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); VKAPI_ATTR VkResult CreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); VKAPI_ATTR void DestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); -VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); -VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); -VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); VKAPI_ATTR void GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); -VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int32_t* grallocUsage); -VKAPI_ATTR VkResult GetSwapchainGrallocUsage2ANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage); +VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage); VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence); VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd); -VKAPI_ATTR VkResult CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); -VKAPI_ATTR void DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR void DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); -VKAPI_ATTR void GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures); -VKAPI_ATTR void GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties); -VKAPI_ATTR void GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties); -VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties); -VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties); -VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties); -VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties); +VKAPI_ATTR VkResult GetSwapchainGrallocUsage2ANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage); VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage); VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence); VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd); diff --git a/vulkan/scripts/api_generator.py b/vulkan/scripts/api_generator.py index 05dc9957b0..a0c648cc90 100644 --- a/vulkan/scripts/api_generator.py +++ b/vulkan/scripts/api_generator.py @@ -63,7 +63,7 @@ bool InitDispatchTable( #endif // LIBVULKAN_API_GEN_H """ - genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','api_gen2.h') + genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','api_gen.h') with open(genfile, 'w') as f: instanceDispatchTableEntries = [] deviceDispatchTableEntries = [] @@ -93,6 +93,7 @@ bool InitDispatchTable( f.write (tail) f.close() + gencom.runClangFormat(genfile) def defineInitProc(name, f): f.write ('#define UNLIKELY(expr) __builtin_expect((expr), 0)\n') @@ -233,7 +234,7 @@ def apiDispatch(functionName, f): def api_gencpp(): - genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','api_gen2.cpp') + genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','api_gen.cpp') header = """#include <log/log.h> #include <string.h> @@ -341,4 +342,5 @@ namespace api {\n\n""") f.write ('}\n\n') gencom.clang_on(f, 0) - + f.close() + gencom.runClangFormat(genfile) diff --git a/vulkan/scripts/code_generator.py b/vulkan/scripts/code_generator.py index 9e14b2886a..39fedf4777 100755 --- a/vulkan/scripts/code_generator.py +++ b/vulkan/scripts/code_generator.py @@ -20,6 +20,7 @@ import generator_common as gencom import api_generator as apigen import driver_generator as drivergen +import null_generator as nullgen if __name__ == '__main__': gencom.parseVulkanRegistry() @@ -27,3 +28,5 @@ if __name__ == '__main__': apigen.api_gencpp() drivergen.driver_genh() drivergen.driver_gencpp() + nullgen.null_driver_genh() + nullgen.null_driver_gencpp() diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index 92326caf46..04d9f239e7 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -132,7 +132,7 @@ def driver_genh(): namespace vulkan { namespace driver {\n\n""" - genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','driver_gen2.h') + genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','driver_gen.h') with open(genfile, 'w') as f: f.write (gencom.copyright) f.write (gencom.warning) @@ -166,6 +166,8 @@ bool InitDriverTable(VkDevice dev, } // namespace vulkan #endif // LIBVULKAN_DRIVER_TABLE_H\n""") + f.close() + gencom.runClangFormat(genfile) def isIntercepted(functionName): switchCase = { @@ -317,7 +319,7 @@ namespace { // clang-format off\n\n""" - genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','driver_gen2.cpp') + genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','driver_gen.cpp') with open(genfile, 'w') as f: f.write (gencom.copyright) @@ -390,4 +392,5 @@ namespace { f.write ('\n' + gencom.clang_off_spaces + 'return success;\n') f.write ('}\n\n} // namespace driver\n} // namespace vulkan\n\n') gencom.clang_on(f, 0) - + f.close() + gencom.runClangFormat(genfile) diff --git a/vulkan/scripts/generator_common.py b/vulkan/scripts/generator_common.py index 51ad6f5d01..d9f97e1760 100644 --- a/vulkan/scripts/generator_common.py +++ b/vulkan/scripts/generator_common.py @@ -17,6 +17,8 @@ # This script provides the common functions for generating the # vulkan framework directly from the vulkan registry (vk.xml). +from subprocess import check_call + copyright = """/* * Copyright 2016 The Android Open Source Project * @@ -75,6 +77,10 @@ exportedExtensions = [ 'VK_ANDROID_external_memory_android_hardware_buffer' ] +def runClangFormat(args): + clang_call = ["clang-format", "--style", "file", "-i", args] + check_call (clang_call) + def isExtensionInternal(extensionName): if extensionName == 'VK_ANDROID_native_buffer': return True @@ -223,12 +229,12 @@ def parseVulkanRegistry(): allCommandsList.append('vkGetSwapchainGrallocUsage2ANDROID') returnTypeDict['vkGetSwapchainGrallocUsage2ANDROID'] = 'VkResult' paramDict['vkGetSwapchainGrallocUsage2ANDROID'] = [ - ('VkDevice ', 'device', None), - ('VkFormat ', 'format', None), - ('VkImageUsageFlags', 'imageUsage', None), - ('VkSwapchainImageUsageFlagsANDROID ', 'swapchainImageUsage', None), - ('u64* ', 'grallocConsumerUsage', None), - ('u64* ', 'grallocProducerUsage', None) + ('VkDevice ', 'device'), + ('VkFormat ', 'format'), + ('VkImageUsageFlags ', 'imageUsage'), + ('VkSwapchainImageUsageFlagsANDROID ', 'swapchainImageUsage'), + ('uint64_t* ', 'grallocConsumerUsage'), + ('uint64_t* ', 'grallocProducerUsage') ] for feature in root.iter('feature'): diff --git a/vulkan/scripts/null_generator.py b/vulkan/scripts/null_generator.py new file mode 100644 index 0000000000..ee8762e3b4 --- /dev/null +++ b/vulkan/scripts/null_generator.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 +# +# Copyright 2019 The Android Open Source Project +# +# 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. +# +# This script provides the functions for generating the null driver +# framework directly from the vulkan registry (vk.xml). + +import generator_common as gencom +import os + +copyright = """/* + * Copyright 2015 The Android Open Source Project + * + * 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. + */ + +""" + +def isDriverExtension(extensionName): + switchCase = { + 'VK_ANDROID_native_buffer' : True, + 'VK_EXT_debug_report' : True, + 'VK_KHR_get_physical_device_properties2' : True + } + + if extensionName in switchCase: + return switchCase[extensionName] + return False + +def isDriverFunction(functionName): + if functionName in gencom.extensionsDict: + return isDriverExtension(gencom.extensionsDict[functionName]) + return True + +def null_driver_genh(): + header = """#ifndef NULLDRV_NULL_DRIVER_H +#define NULLDRV_NULL_DRIVER_H 1 + +#include <vulkan/vk_android_native_buffer.h> +#include <vulkan/vulkan.h> + +namespace null_driver { + +PFN_vkVoidFunction GetGlobalProcAddr(const char* name); +PFN_vkVoidFunction GetInstanceProcAddr(const char* name); + +""" + genfile = os.path.join(os.path.dirname(__file__),'..','nulldrv','null_driver_gen.h') + with open(genfile, 'w') as f: + f.write (copyright) + f.write (gencom.warning) + f.write (header) + gencom.clang_off(f,0) + + for cmds in gencom.allCommandsList: + if isDriverFunction(cmds): + paramList = [''.join(i) for i in gencom.paramDict[cmds]] + f.write ('VKAPI_ATTR ' + gencom.returnTypeDict[cmds] + ' ' + cmds[2:] + '(' +', '.join(paramList) + ');\n') + f.write ("""VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage); +VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence); +VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);\n""") + gencom.clang_on(f,0) + + f.write ('\n} // namespace null_driver\n') + f.write ('\n#endif // NULLDRV_NULL_DRIVER_H\n') + f.close() + gencom.runClangFormat(genfile) + +def null_driver_gencpp(): + header = """#include <algorithm> + +#include "null_driver_gen.h" + +using namespace null_driver; + +namespace { + +struct NameProc { + const char* name; + PFN_vkVoidFunction proc; +}; + +PFN_vkVoidFunction Lookup(const char* name, + const NameProc* begin, + const NameProc* end) { + const auto& entry = std::lower_bound( + begin, end, name, + [](const NameProc& e, const char* n) { return strcmp(e.name, n) < 0; }); + if (entry == end || strcmp(entry->name, name) != 0) + return nullptr; + return entry->proc; +} + +template <size_t N> +PFN_vkVoidFunction Lookup(const char* name, const NameProc (&procs)[N]) { + return Lookup(name, procs, procs + N); +} + +const NameProc kGlobalProcs[] = { +""" + genfile = os.path.join(os.path.dirname(__file__),'..','nulldrv','null_driver_gen.cpp') + with open(genfile, 'w') as f: + f.write (copyright) + f.write (gencom.warning) + f.write (header) + gencom.clang_off(f,1) + + sortedCommandsList = sorted(gencom.allCommandsList) + for cmds in sortedCommandsList: + if isDriverFunction(cmds) and gencom.getDispatchTableType(cmds) == 'Global': + f.write (gencom.clang_off_spaces + '{\"' + cmds + '\", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_' + cmds + '>(' + cmds[2:] + '))},\n') + gencom.clang_on(f,1) + f.write ('};\n\n') + + f.write ('const NameProc kInstanceProcs[] = {\n') + gencom.clang_off(f,1) + for cmds in sortedCommandsList: + if isDriverFunction(cmds): + f.write (gencom.clang_off_spaces + '{\"' + cmds + '\", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_' + cmds + '>(' + cmds[2:] + '))},\n') + gencom.clang_on(f,1) + f.write ('};\n\n} // namespace\n\n') + + f.write ("""namespace null_driver { + +PFN_vkVoidFunction GetGlobalProcAddr(const char* name) { + return Lookup(name, kGlobalProcs); +} + +PFN_vkVoidFunction GetInstanceProcAddr(const char* name) { + return Lookup(name, kInstanceProcs); +} + +} // namespace null_driver\n""") + f.close() + gencom.runClangFormat(genfile) + |