{{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 #include #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 &extensions); bool InitDispatchTable( VkDevice dev, PFN_vkGetDeviceProcAddr get_proc, const std::bitset &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 #include #include ¶ // 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 &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 &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 #include #include ¶ 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 &extensions); bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc, const std::bitset &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 #include #include ¶ #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.InterceptedExtensions") | 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 &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 &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(obj, proc) do { \ data.{{$}}.proc = reinterpret_cast( \ get_proc(obj, "vk" # proc)); \ if (UNLIKELY(!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 (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, obj, proc) do { \ if (extensions[driver::ProcHook::ext]) \ INIT_PROC(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({{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(§ {{Macro "BaseName" $f}}) }, {{/* redirect vkGetInstanceProcAddr to itself */}} {{else if eq $f.Name "vkGetInstanceProcAddr"}} { "{{$f.Name}}", reinterpret_cast({{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({{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(§ {{Macro "BaseName" $f}}); {{else if eq $f.Name "vkGetDeviceProcAddr"}} if (strcmp(pName, "{{$f.Name}}") == 0) return § reinterpret_cast(§ {{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_KHR_android_surface VK_KHR_surface VK_KHR_swapchain {{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 "vkGetDeviceQueue"}}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 {{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.InterceptedExtensions") | 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, obj, proc) do { \ if (extensions[ProcHook::ext]) \ INIT_PROC(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({{$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({{$base}}), nullptr, {{end}} {{else}} ProcHook::EXTENSION_CORE, reinterpret_cast({{$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({{$base}}), reinterpret_cast(checked{{$base}}), {{end}} {{else}} ProcHook::EXTENSION_CORE, reinterpret_cast({{$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 "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 "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 {{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_xlib_surface"}}true {{else if eq $ext "VK_KHR_xcb_surface"}}true {{else if eq $ext "VK_KHR_wayland_surface"}}true {{else if eq $ext "VK_KHR_mir_surface"}}true {{else if eq $ext "VK_KHR_win32_surface"}}true {{end}} {{end}} {{/* ------------------------------------------------------------------------------ Reports whether an extension is implemented entirely by the loader, so drivers should not enumerate it. ------------------------------------------------------------------------------ */}} {{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 {{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}}