Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Namespaces | Macros | Variables
VulkanInterface.cpp File Reference
#include "include/gpu/vk/VulkanExtensions.h"
#include "src/gpu/vk/VulkanInterface.h"

Go to the source code of this file.

Namespaces

namespace  skgpu
 

Macros

#define ACQUIRE_PROC(name, instance, device)    fFunctions.f##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, instance, device))
 
#define ACQUIRE_PROC_SUFFIX(name, suffix, instance, device)
 
#define RETURN_FALSE_INTERFACE
 

Variables

constexpr int skgpu::kIsDebug = 0
 

Macro Definition Documentation

◆ ACQUIRE_PROC

#define ACQUIRE_PROC (   name,
  instance,
  device 
)     fFunctions.f##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, instance, device))

Definition at line 13 of file VulkanInterface.cpp.

24 {
25 if (getProc == nullptr) {
26 return;
27 }
28 // Global/Loader Procs.
29 ACQUIRE_PROC(CreateInstance, VK_NULL_HANDLE, VK_NULL_HANDLE);
30 ACQUIRE_PROC(EnumerateInstanceExtensionProperties, VK_NULL_HANDLE, VK_NULL_HANDLE);
31 ACQUIRE_PROC(EnumerateInstanceLayerProperties, VK_NULL_HANDLE, VK_NULL_HANDLE);
32
33 // Instance Procs.
34 ACQUIRE_PROC(EnumeratePhysicalDevices, instance, VK_NULL_HANDLE);
35 ACQUIRE_PROC(GetPhysicalDeviceFeatures, instance, VK_NULL_HANDLE);
36 ACQUIRE_PROC(GetPhysicalDeviceFormatProperties, instance, VK_NULL_HANDLE);
37 ACQUIRE_PROC(GetPhysicalDeviceImageFormatProperties, instance, VK_NULL_HANDLE);
38 ACQUIRE_PROC(GetPhysicalDeviceProperties, instance, VK_NULL_HANDLE);
39 ACQUIRE_PROC(GetPhysicalDeviceQueueFamilyProperties, instance, VK_NULL_HANDLE);
40 ACQUIRE_PROC(GetPhysicalDeviceMemoryProperties, instance, VK_NULL_HANDLE);
41 ACQUIRE_PROC(GetPhysicalDeviceSparseImageFormatProperties, instance, VK_NULL_HANDLE);
42 ACQUIRE_PROC(DestroyInstance, instance, VK_NULL_HANDLE);
43 ACQUIRE_PROC(CreateDevice, instance, VK_NULL_HANDLE);
44 ACQUIRE_PROC(DestroyDevice, instance, VK_NULL_HANDLE);
45 ACQUIRE_PROC(EnumerateDeviceExtensionProperties, instance, VK_NULL_HANDLE);
46 ACQUIRE_PROC(EnumerateDeviceLayerProperties, instance, VK_NULL_HANDLE);
47
48 // Device Procs.
49 ACQUIRE_PROC(GetDeviceQueue, VK_NULL_HANDLE, device);
50 ACQUIRE_PROC(QueueSubmit, VK_NULL_HANDLE, device);
51 ACQUIRE_PROC(QueueWaitIdle, VK_NULL_HANDLE, device);
52 ACQUIRE_PROC(DeviceWaitIdle, VK_NULL_HANDLE, device);
53 ACQUIRE_PROC(AllocateMemory, VK_NULL_HANDLE, device);
54 ACQUIRE_PROC(FreeMemory, VK_NULL_HANDLE, device);
55 ACQUIRE_PROC(MapMemory, VK_NULL_HANDLE, device);
56 ACQUIRE_PROC(UnmapMemory, VK_NULL_HANDLE, device);
57 ACQUIRE_PROC(FlushMappedMemoryRanges, VK_NULL_HANDLE, device);
58 ACQUIRE_PROC(InvalidateMappedMemoryRanges, VK_NULL_HANDLE, device);
59 ACQUIRE_PROC(GetDeviceMemoryCommitment, VK_NULL_HANDLE, device);
60 ACQUIRE_PROC(BindBufferMemory, VK_NULL_HANDLE, device);
61 ACQUIRE_PROC(BindImageMemory, VK_NULL_HANDLE, device);
62 ACQUIRE_PROC(GetBufferMemoryRequirements, VK_NULL_HANDLE, device);
63 ACQUIRE_PROC(GetImageMemoryRequirements, VK_NULL_HANDLE, device);
64 ACQUIRE_PROC(GetImageSparseMemoryRequirements, VK_NULL_HANDLE, device);
65 ACQUIRE_PROC(QueueBindSparse, VK_NULL_HANDLE, device);
66 ACQUIRE_PROC(CreateFence, VK_NULL_HANDLE, device);
67 ACQUIRE_PROC(DestroyFence, VK_NULL_HANDLE, device);
68 ACQUIRE_PROC(ResetFences, VK_NULL_HANDLE, device);
69 ACQUIRE_PROC(GetFenceStatus, VK_NULL_HANDLE, device);
70 ACQUIRE_PROC(WaitForFences, VK_NULL_HANDLE, device);
71 ACQUIRE_PROC(CreateSemaphore, VK_NULL_HANDLE, device);
72 ACQUIRE_PROC(DestroySemaphore, VK_NULL_HANDLE, device);
73 ACQUIRE_PROC(CreateEvent, VK_NULL_HANDLE, device);
74 ACQUIRE_PROC(DestroyEvent, VK_NULL_HANDLE, device);
75 ACQUIRE_PROC(GetEventStatus, VK_NULL_HANDLE, device);
76 ACQUIRE_PROC(SetEvent, VK_NULL_HANDLE, device);
77 ACQUIRE_PROC(ResetEvent, VK_NULL_HANDLE, device);
78 ACQUIRE_PROC(CreateQueryPool, VK_NULL_HANDLE, device);
79 ACQUIRE_PROC(DestroyQueryPool, VK_NULL_HANDLE, device);
80 ACQUIRE_PROC(GetQueryPoolResults, VK_NULL_HANDLE, device);
81 ACQUIRE_PROC(CreateBuffer, VK_NULL_HANDLE, device);
82 ACQUIRE_PROC(DestroyBuffer, VK_NULL_HANDLE, device);
83 ACQUIRE_PROC(CreateBufferView, VK_NULL_HANDLE, device);
84 ACQUIRE_PROC(DestroyBufferView, VK_NULL_HANDLE, device);
85 ACQUIRE_PROC(CreateImage, VK_NULL_HANDLE, device);
86 ACQUIRE_PROC(DestroyImage, VK_NULL_HANDLE, device);
87 ACQUIRE_PROC(GetImageSubresourceLayout, VK_NULL_HANDLE, device);
88 ACQUIRE_PROC(CreateImageView, VK_NULL_HANDLE, device);
89 ACQUIRE_PROC(DestroyImageView, VK_NULL_HANDLE, device);
90 ACQUIRE_PROC(CreateShaderModule, VK_NULL_HANDLE, device);
91 ACQUIRE_PROC(DestroyShaderModule, VK_NULL_HANDLE, device);
92 ACQUIRE_PROC(CreatePipelineCache, VK_NULL_HANDLE, device);
93 ACQUIRE_PROC(DestroyPipelineCache, VK_NULL_HANDLE, device);
94 ACQUIRE_PROC(GetPipelineCacheData, VK_NULL_HANDLE, device);
95 ACQUIRE_PROC(MergePipelineCaches, VK_NULL_HANDLE, device);
96 ACQUIRE_PROC(CreateGraphicsPipelines, VK_NULL_HANDLE, device);
97 ACQUIRE_PROC(CreateComputePipelines, VK_NULL_HANDLE, device);
98 ACQUIRE_PROC(DestroyPipeline, VK_NULL_HANDLE, device);
99 ACQUIRE_PROC(CreatePipelineLayout, VK_NULL_HANDLE, device);
100 ACQUIRE_PROC(DestroyPipelineLayout, VK_NULL_HANDLE, device);
101 ACQUIRE_PROC(CreateSampler, VK_NULL_HANDLE, device);
102 ACQUIRE_PROC(DestroySampler, VK_NULL_HANDLE, device);
103 ACQUIRE_PROC(CreateDescriptorSetLayout, VK_NULL_HANDLE, device);
104 ACQUIRE_PROC(DestroyDescriptorSetLayout, VK_NULL_HANDLE, device);
105 ACQUIRE_PROC(CreateDescriptorPool, VK_NULL_HANDLE, device);
106 ACQUIRE_PROC(DestroyDescriptorPool, VK_NULL_HANDLE, device);
107 ACQUIRE_PROC(ResetDescriptorPool, VK_NULL_HANDLE, device);
108 ACQUIRE_PROC(AllocateDescriptorSets, VK_NULL_HANDLE, device);
109 ACQUIRE_PROC(FreeDescriptorSets, VK_NULL_HANDLE, device);
110 ACQUIRE_PROC(UpdateDescriptorSets, VK_NULL_HANDLE, device);
111 ACQUIRE_PROC(CreateFramebuffer, VK_NULL_HANDLE, device);
112 ACQUIRE_PROC(DestroyFramebuffer, VK_NULL_HANDLE, device);
113 ACQUIRE_PROC(CreateRenderPass, VK_NULL_HANDLE, device);
114 ACQUIRE_PROC(DestroyRenderPass, VK_NULL_HANDLE, device);
115 ACQUIRE_PROC(GetRenderAreaGranularity, VK_NULL_HANDLE, device);
116 ACQUIRE_PROC(CreateCommandPool, VK_NULL_HANDLE, device);
117 ACQUIRE_PROC(DestroyCommandPool, VK_NULL_HANDLE, device);
118 ACQUIRE_PROC(ResetCommandPool, VK_NULL_HANDLE, device);
119 ACQUIRE_PROC(AllocateCommandBuffers, VK_NULL_HANDLE, device);
120 ACQUIRE_PROC(FreeCommandBuffers, VK_NULL_HANDLE, device);
121 ACQUIRE_PROC(BeginCommandBuffer, VK_NULL_HANDLE, device);
122 ACQUIRE_PROC(EndCommandBuffer, VK_NULL_HANDLE, device);
123 ACQUIRE_PROC(ResetCommandBuffer, VK_NULL_HANDLE, device);
124 ACQUIRE_PROC(CmdBindPipeline, VK_NULL_HANDLE, device);
125 ACQUIRE_PROC(CmdSetViewport, VK_NULL_HANDLE, device);
126 ACQUIRE_PROC(CmdSetScissor, VK_NULL_HANDLE, device);
127 ACQUIRE_PROC(CmdSetLineWidth, VK_NULL_HANDLE, device);
128 ACQUIRE_PROC(CmdSetDepthBias, VK_NULL_HANDLE, device);
129 ACQUIRE_PROC(CmdSetBlendConstants, VK_NULL_HANDLE, device);
130 ACQUIRE_PROC(CmdSetDepthBounds, VK_NULL_HANDLE, device);
131 ACQUIRE_PROC(CmdSetStencilCompareMask, VK_NULL_HANDLE, device);
132 ACQUIRE_PROC(CmdSetStencilWriteMask, VK_NULL_HANDLE, device);
133 ACQUIRE_PROC(CmdSetStencilReference, VK_NULL_HANDLE, device);
134 ACQUIRE_PROC(CmdBindDescriptorSets, VK_NULL_HANDLE, device);
135 ACQUIRE_PROC(CmdBindIndexBuffer, VK_NULL_HANDLE, device);
136 ACQUIRE_PROC(CmdBindVertexBuffers, VK_NULL_HANDLE, device);
137 ACQUIRE_PROC(CmdDraw, VK_NULL_HANDLE, device);
138 ACQUIRE_PROC(CmdDrawIndexed, VK_NULL_HANDLE, device);
139 ACQUIRE_PROC(CmdDrawIndirect, VK_NULL_HANDLE, device);
140 ACQUIRE_PROC(CmdDrawIndexedIndirect, VK_NULL_HANDLE, device);
141 ACQUIRE_PROC(CmdDispatch, VK_NULL_HANDLE, device);
142 ACQUIRE_PROC(CmdDispatchIndirect, VK_NULL_HANDLE, device);
143 ACQUIRE_PROC(CmdCopyBuffer, VK_NULL_HANDLE, device);
144 ACQUIRE_PROC(CmdCopyImage, VK_NULL_HANDLE, device);
145 ACQUIRE_PROC(CmdBlitImage, VK_NULL_HANDLE, device);
146 ACQUIRE_PROC(CmdCopyBufferToImage, VK_NULL_HANDLE, device);
147 ACQUIRE_PROC(CmdCopyImageToBuffer, VK_NULL_HANDLE, device);
148 ACQUIRE_PROC(CmdUpdateBuffer, VK_NULL_HANDLE, device);
149 ACQUIRE_PROC(CmdFillBuffer, VK_NULL_HANDLE, device);
150 ACQUIRE_PROC(CmdClearColorImage, VK_NULL_HANDLE, device);
151 ACQUIRE_PROC(CmdClearDepthStencilImage, VK_NULL_HANDLE, device);
152 ACQUIRE_PROC(CmdClearAttachments, VK_NULL_HANDLE, device);
153 ACQUIRE_PROC(CmdResolveImage, VK_NULL_HANDLE, device);
154 ACQUIRE_PROC(CmdSetEvent, VK_NULL_HANDLE, device);
155 ACQUIRE_PROC(CmdResetEvent, VK_NULL_HANDLE, device);
156 ACQUIRE_PROC(CmdWaitEvents, VK_NULL_HANDLE, device);
157 ACQUIRE_PROC(CmdPipelineBarrier, VK_NULL_HANDLE, device);
158 ACQUIRE_PROC(CmdBeginQuery, VK_NULL_HANDLE, device);
159 ACQUIRE_PROC(CmdEndQuery, VK_NULL_HANDLE, device);
160 ACQUIRE_PROC(CmdResetQueryPool, VK_NULL_HANDLE, device);
161 ACQUIRE_PROC(CmdWriteTimestamp, VK_NULL_HANDLE, device);
162 ACQUIRE_PROC(CmdCopyQueryPoolResults, VK_NULL_HANDLE, device);
163 ACQUIRE_PROC(CmdPushConstants, VK_NULL_HANDLE, device);
164 ACQUIRE_PROC(CmdBeginRenderPass, VK_NULL_HANDLE, device);
165 ACQUIRE_PROC(CmdNextSubpass, VK_NULL_HANDLE, device);
166 ACQUIRE_PROC(CmdEndRenderPass, VK_NULL_HANDLE, device);
167 ACQUIRE_PROC(CmdExecuteCommands, VK_NULL_HANDLE, device);
168
169 // Functions for VK_KHR_get_physical_device_properties2
170 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0)) {
171 ACQUIRE_PROC(GetPhysicalDeviceFeatures2, instance, VK_NULL_HANDLE);
172 ACQUIRE_PROC(GetPhysicalDeviceProperties2, instance, VK_NULL_HANDLE);
173 ACQUIRE_PROC(GetPhysicalDeviceFormatProperties2, instance, VK_NULL_HANDLE);
174 ACQUIRE_PROC(GetPhysicalDeviceImageFormatProperties2, instance, VK_NULL_HANDLE);
175 ACQUIRE_PROC(GetPhysicalDeviceQueueFamilyProperties2, instance, VK_NULL_HANDLE);
176 ACQUIRE_PROC(GetPhysicalDeviceMemoryProperties2, instance, VK_NULL_HANDLE);
177 ACQUIRE_PROC(GetPhysicalDeviceSparseImageFormatProperties2, instance, VK_NULL_HANDLE);
178 } else if (extensions->hasExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
179 1)) {
180 ACQUIRE_PROC_SUFFIX(GetPhysicalDeviceFeatures2, KHR, instance, VK_NULL_HANDLE);
181 ACQUIRE_PROC_SUFFIX(GetPhysicalDeviceProperties2, KHR, instance, VK_NULL_HANDLE);
182 ACQUIRE_PROC_SUFFIX(GetPhysicalDeviceFormatProperties2, KHR, instance, VK_NULL_HANDLE);
183 ACQUIRE_PROC_SUFFIX(GetPhysicalDeviceImageFormatProperties2, KHR, instance, VK_NULL_HANDLE);
184 ACQUIRE_PROC_SUFFIX(GetPhysicalDeviceQueueFamilyProperties2, KHR, instance, VK_NULL_HANDLE);
185 ACQUIRE_PROC_SUFFIX(GetPhysicalDeviceMemoryProperties2, KHR, instance, VK_NULL_HANDLE);
186 ACQUIRE_PROC_SUFFIX(GetPhysicalDeviceSparseImageFormatProperties2, KHR, instance,
187 VK_NULL_HANDLE);
188 }
189
190 // Functions for VK_KHR_get_memory_requirements2
191 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0)) {
192 ACQUIRE_PROC(GetImageMemoryRequirements2, VK_NULL_HANDLE, device);
193 ACQUIRE_PROC(GetBufferMemoryRequirements2, VK_NULL_HANDLE, device);
194 ACQUIRE_PROC(GetImageSparseMemoryRequirements2, VK_NULL_HANDLE, device);
195 } else if (extensions->hasExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1)) {
196 ACQUIRE_PROC_SUFFIX(GetImageMemoryRequirements2, KHR, VK_NULL_HANDLE, device);
197 ACQUIRE_PROC_SUFFIX(GetBufferMemoryRequirements2, KHR, VK_NULL_HANDLE, device);
198 ACQUIRE_PROC_SUFFIX(GetImageSparseMemoryRequirements2, KHR, VK_NULL_HANDLE, device);
199 }
200
201 // Functions for VK_KHR_bind_memory2
202 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0)) {
203 ACQUIRE_PROC(BindBufferMemory2, VK_NULL_HANDLE, device);
204 ACQUIRE_PROC(BindImageMemory2, VK_NULL_HANDLE, device);
205 } else if (extensions->hasExtension(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1)) {
206 ACQUIRE_PROC_SUFFIX(BindBufferMemory2, KHR, VK_NULL_HANDLE, device);
207 ACQUIRE_PROC_SUFFIX(BindImageMemory2, KHR, VK_NULL_HANDLE, device);
208 }
209
210 // Functions for VK_KHR_maintenance1 or vulkan 1.1
211 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0)) {
212 ACQUIRE_PROC(TrimCommandPool, VK_NULL_HANDLE, device);
213 } else if (extensions->hasExtension(VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1)) {
214 ACQUIRE_PROC_SUFFIX(TrimCommandPool, KHR, VK_NULL_HANDLE, device);
215 }
216
217 // Functions for VK_KHR_maintenance3 or vulkan 1.1
218 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0)) {
219 ACQUIRE_PROC(GetDescriptorSetLayoutSupport, VK_NULL_HANDLE, device);
220 } else if (extensions->hasExtension(VK_KHR_MAINTENANCE3_EXTENSION_NAME, 1)) {
221 ACQUIRE_PROC_SUFFIX(GetDescriptorSetLayoutSupport, KHR, VK_NULL_HANDLE, device);
222 }
223
224 // Functions for VK_KHR_external_memory_capabilities
225 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0)) {
226 ACQUIRE_PROC(GetPhysicalDeviceExternalBufferProperties, instance, VK_NULL_HANDLE);
227 } else if (extensions->hasExtension(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1)) {
228 ACQUIRE_PROC_SUFFIX(GetPhysicalDeviceExternalBufferProperties, KHR, instance,
229 VK_NULL_HANDLE);
230 }
231
232 // Functions for VK_KHR_sampler_ycbcr_conversion
233 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0)) {
234 ACQUIRE_PROC(CreateSamplerYcbcrConversion, VK_NULL_HANDLE, device);
235 ACQUIRE_PROC(DestroySamplerYcbcrConversion, VK_NULL_HANDLE, device);
236 } else if (extensions->hasExtension(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, 1)) {
237 ACQUIRE_PROC_SUFFIX(CreateSamplerYcbcrConversion, KHR, VK_NULL_HANDLE, device);
238 ACQUIRE_PROC_SUFFIX(DestroySamplerYcbcrConversion, KHR, VK_NULL_HANDLE, device);
239 }
240
241 // Functions for VK_EXT_device_fault
242 if (extensions->hasExtension(VK_EXT_DEVICE_FAULT_EXTENSION_NAME, 1)) {
243 ACQUIRE_PROC_SUFFIX(GetDeviceFaultInfo, EXT, VK_NULL_HANDLE, device);
244 }
245
246#ifdef SK_BUILD_FOR_ANDROID
247 // Functions for VK_ANDROID_external_memory_android_hardware_buffer
248 if (extensions->hasExtension(
249 VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 2)) {
250 ACQUIRE_PROC_SUFFIX(GetAndroidHardwareBufferProperties, ANDROID, VK_NULL_HANDLE, device);
251 ACQUIRE_PROC_SUFFIX(GetMemoryAndroidHardwareBuffer, ANDROID, VK_NULL_HANDLE, device);
252 }
253#endif
254
255}
256
257#ifdef SK_DEBUG
258 constexpr int kIsDebug = 1;
259#else
260 constexpr int kIsDebug = 0;
261#endif
262
263#define RETURN_FALSE_INTERFACE \
264 if (kIsDebug) { SkDebugf("%s:%d VulkanInterface::validate() failed.\n", __FILE__, __LINE__); } \
265 return false;
266
267bool VulkanInterface::validate(uint32_t instanceVersion,
268 uint32_t physicalDeviceVersion,
269 const VulkanExtensions* extensions) const {
270 // functions that are always required
271 if (nullptr == fFunctions.fCreateInstance ||
272 nullptr == fFunctions.fDestroyInstance ||
273 nullptr == fFunctions.fEnumeratePhysicalDevices ||
274 nullptr == fFunctions.fGetPhysicalDeviceFeatures ||
275 nullptr == fFunctions.fGetPhysicalDeviceFormatProperties ||
276 nullptr == fFunctions.fGetPhysicalDeviceImageFormatProperties ||
277 nullptr == fFunctions.fGetPhysicalDeviceProperties ||
278 nullptr == fFunctions.fGetPhysicalDeviceQueueFamilyProperties ||
279 nullptr == fFunctions.fGetPhysicalDeviceMemoryProperties ||
280 nullptr == fFunctions.fCreateDevice ||
281 nullptr == fFunctions.fDestroyDevice ||
282 nullptr == fFunctions.fEnumerateInstanceExtensionProperties ||
283 nullptr == fFunctions.fEnumerateDeviceExtensionProperties ||
284 nullptr == fFunctions.fEnumerateInstanceLayerProperties ||
285 nullptr == fFunctions.fEnumerateDeviceLayerProperties ||
286 nullptr == fFunctions.fGetDeviceQueue ||
287 nullptr == fFunctions.fQueueSubmit ||
288 nullptr == fFunctions.fQueueWaitIdle ||
289 nullptr == fFunctions.fDeviceWaitIdle ||
290 nullptr == fFunctions.fAllocateMemory ||
291 nullptr == fFunctions.fFreeMemory ||
292 nullptr == fFunctions.fMapMemory ||
293 nullptr == fFunctions.fUnmapMemory ||
294 nullptr == fFunctions.fFlushMappedMemoryRanges ||
295 nullptr == fFunctions.fInvalidateMappedMemoryRanges ||
296 nullptr == fFunctions.fGetDeviceMemoryCommitment ||
297 nullptr == fFunctions.fBindBufferMemory ||
298 nullptr == fFunctions.fBindImageMemory ||
299 nullptr == fFunctions.fGetBufferMemoryRequirements ||
300 nullptr == fFunctions.fGetImageMemoryRequirements ||
301 nullptr == fFunctions.fGetImageSparseMemoryRequirements ||
302 nullptr == fFunctions.fGetPhysicalDeviceSparseImageFormatProperties ||
303 nullptr == fFunctions.fQueueBindSparse ||
304 nullptr == fFunctions.fCreateFence ||
305 nullptr == fFunctions.fDestroyFence ||
306 nullptr == fFunctions.fResetFences ||
307 nullptr == fFunctions.fGetFenceStatus ||
308 nullptr == fFunctions.fWaitForFences ||
309 nullptr == fFunctions.fCreateSemaphore ||
310 nullptr == fFunctions.fDestroySemaphore ||
311 nullptr == fFunctions.fCreateEvent ||
312 nullptr == fFunctions.fDestroyEvent ||
313 nullptr == fFunctions.fGetEventStatus ||
314 nullptr == fFunctions.fSetEvent ||
315 nullptr == fFunctions.fResetEvent ||
316 nullptr == fFunctions.fCreateQueryPool ||
317 nullptr == fFunctions.fDestroyQueryPool ||
318 nullptr == fFunctions.fGetQueryPoolResults ||
319 nullptr == fFunctions.fCreateBuffer ||
320 nullptr == fFunctions.fDestroyBuffer ||
321 nullptr == fFunctions.fCreateBufferView ||
322 nullptr == fFunctions.fDestroyBufferView ||
323 nullptr == fFunctions.fCreateImage ||
324 nullptr == fFunctions.fDestroyImage ||
325 nullptr == fFunctions.fGetImageSubresourceLayout ||
326 nullptr == fFunctions.fCreateImageView ||
327 nullptr == fFunctions.fDestroyImageView ||
328 nullptr == fFunctions.fCreateShaderModule ||
329 nullptr == fFunctions.fDestroyShaderModule ||
330 nullptr == fFunctions.fCreatePipelineCache ||
331 nullptr == fFunctions.fDestroyPipelineCache ||
332 nullptr == fFunctions.fGetPipelineCacheData ||
333 nullptr == fFunctions.fMergePipelineCaches ||
334 nullptr == fFunctions.fCreateGraphicsPipelines ||
335 nullptr == fFunctions.fCreateComputePipelines ||
336 nullptr == fFunctions.fDestroyPipeline ||
337 nullptr == fFunctions.fCreatePipelineLayout ||
338 nullptr == fFunctions.fDestroyPipelineLayout ||
339 nullptr == fFunctions.fCreateSampler ||
340 nullptr == fFunctions.fDestroySampler ||
341 nullptr == fFunctions.fCreateDescriptorSetLayout ||
342 nullptr == fFunctions.fDestroyDescriptorSetLayout ||
343 nullptr == fFunctions.fCreateDescriptorPool ||
344 nullptr == fFunctions.fDestroyDescriptorPool ||
345 nullptr == fFunctions.fResetDescriptorPool ||
346 nullptr == fFunctions.fAllocateDescriptorSets ||
347 nullptr == fFunctions.fFreeDescriptorSets ||
348 nullptr == fFunctions.fUpdateDescriptorSets ||
349 nullptr == fFunctions.fCreateFramebuffer ||
350 nullptr == fFunctions.fDestroyFramebuffer ||
351 nullptr == fFunctions.fCreateRenderPass ||
352 nullptr == fFunctions.fDestroyRenderPass ||
353 nullptr == fFunctions.fGetRenderAreaGranularity ||
354 nullptr == fFunctions.fCreateCommandPool ||
355 nullptr == fFunctions.fDestroyCommandPool ||
356 nullptr == fFunctions.fResetCommandPool ||
357 nullptr == fFunctions.fAllocateCommandBuffers ||
358 nullptr == fFunctions.fFreeCommandBuffers ||
359 nullptr == fFunctions.fBeginCommandBuffer ||
360 nullptr == fFunctions.fEndCommandBuffer ||
361 nullptr == fFunctions.fResetCommandBuffer ||
362 nullptr == fFunctions.fCmdBindPipeline ||
363 nullptr == fFunctions.fCmdSetViewport ||
364 nullptr == fFunctions.fCmdSetScissor ||
365 nullptr == fFunctions.fCmdSetLineWidth ||
366 nullptr == fFunctions.fCmdSetDepthBias ||
367 nullptr == fFunctions.fCmdSetBlendConstants ||
368 nullptr == fFunctions.fCmdSetDepthBounds ||
369 nullptr == fFunctions.fCmdSetStencilCompareMask ||
370 nullptr == fFunctions.fCmdSetStencilWriteMask ||
371 nullptr == fFunctions.fCmdSetStencilReference ||
372 nullptr == fFunctions.fCmdBindDescriptorSets ||
373 nullptr == fFunctions.fCmdBindIndexBuffer ||
374 nullptr == fFunctions.fCmdBindVertexBuffers ||
375 nullptr == fFunctions.fCmdDraw ||
376 nullptr == fFunctions.fCmdDrawIndexed ||
377 nullptr == fFunctions.fCmdDrawIndirect ||
378 nullptr == fFunctions.fCmdDrawIndexedIndirect ||
379 nullptr == fFunctions.fCmdDispatch ||
380 nullptr == fFunctions.fCmdDispatchIndirect ||
381 nullptr == fFunctions.fCmdCopyBuffer ||
382 nullptr == fFunctions.fCmdCopyImage ||
383 nullptr == fFunctions.fCmdBlitImage ||
384 nullptr == fFunctions.fCmdCopyBufferToImage ||
385 nullptr == fFunctions.fCmdCopyImageToBuffer ||
386 nullptr == fFunctions.fCmdUpdateBuffer ||
387 nullptr == fFunctions.fCmdFillBuffer ||
388 nullptr == fFunctions.fCmdClearColorImage ||
389 nullptr == fFunctions.fCmdClearDepthStencilImage ||
390 nullptr == fFunctions.fCmdClearAttachments ||
391 nullptr == fFunctions.fCmdResolveImage ||
392 nullptr == fFunctions.fCmdSetEvent ||
393 nullptr == fFunctions.fCmdResetEvent ||
394 nullptr == fFunctions.fCmdWaitEvents ||
395 nullptr == fFunctions.fCmdPipelineBarrier ||
396 nullptr == fFunctions.fCmdBeginQuery ||
397 nullptr == fFunctions.fCmdEndQuery ||
398 nullptr == fFunctions.fCmdResetQueryPool ||
399 nullptr == fFunctions.fCmdWriteTimestamp ||
400 nullptr == fFunctions.fCmdCopyQueryPoolResults ||
401 nullptr == fFunctions.fCmdPushConstants ||
402 nullptr == fFunctions.fCmdBeginRenderPass ||
403 nullptr == fFunctions.fCmdNextSubpass ||
404 nullptr == fFunctions.fCmdEndRenderPass ||
405 nullptr == fFunctions.fCmdExecuteCommands) {
406 RETURN_FALSE_INTERFACE
407 }
408
409 // Functions for VK_KHR_get_physical_device_properties2 or vulkan 1.1
410 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||
411 extensions->hasExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1)) {
412 if (nullptr == fFunctions.fGetPhysicalDeviceFeatures2 ||
413 nullptr == fFunctions.fGetPhysicalDeviceProperties2 ||
414 nullptr == fFunctions.fGetPhysicalDeviceFormatProperties2 ||
415 nullptr == fFunctions.fGetPhysicalDeviceImageFormatProperties2 ||
416 nullptr == fFunctions.fGetPhysicalDeviceQueueFamilyProperties2 ||
417 nullptr == fFunctions.fGetPhysicalDeviceMemoryProperties2 ||
418 nullptr == fFunctions.fGetPhysicalDeviceSparseImageFormatProperties2) {
419 RETURN_FALSE_INTERFACE
420 }
421 }
422
423 // Functions for VK_KHR_get_memory_requirements2 or vulkan 1.1
424 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||
425 extensions->hasExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1)) {
426 if (nullptr == fFunctions.fGetImageMemoryRequirements2 ||
427 nullptr == fFunctions.fGetBufferMemoryRequirements2 ||
428 nullptr == fFunctions.fGetImageSparseMemoryRequirements2) {
429 RETURN_FALSE_INTERFACE
430 }
431 }
432
433 // Functions for VK_KHR_bind_memory2
434 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||
435 extensions->hasExtension(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1)) {
436 if (nullptr == fFunctions.fBindBufferMemory2 ||
437 nullptr == fFunctions.fBindImageMemory2) {
438 RETURN_FALSE_INTERFACE
439 }
440 }
441
442 // Functions for VK_KHR_maintenance1 or vulkan 1.1
443 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||
444 extensions->hasExtension(VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1)) {
445 if (nullptr == fFunctions.fTrimCommandPool) {
446 RETURN_FALSE_INTERFACE
447 }
448 }
449
450 // Functions for VK_KHR_maintenance3 or vulkan 1.1
451 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||
452 extensions->hasExtension(VK_KHR_MAINTENANCE3_EXTENSION_NAME, 1)) {
453 if (nullptr == fFunctions.fGetDescriptorSetLayoutSupport) {
454 RETURN_FALSE_INTERFACE
455 }
456 }
457
458 // Functions for VK_KHR_external_memory_capabilities
459 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||
460 extensions->hasExtension(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1)) {
461 if (nullptr == fFunctions.fGetPhysicalDeviceExternalBufferProperties) {
462 RETURN_FALSE_INTERFACE
463 }
464 }
465
466 // Functions for VK_KHR_sampler_ycbcr_conversion
467 if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||
468 extensions->hasExtension(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, 1)) {
469 if (nullptr == fFunctions.fCreateSamplerYcbcrConversion ||
470 nullptr == fFunctions.fDestroySamplerYcbcrConversion) {
471 RETURN_FALSE_INTERFACE
472 }
473 }
474
475#ifdef SK_BUILD_FOR_ANDROID
476 // Functions for VK_ANDROID_external_memory_android_hardware_buffer
477 if (extensions->hasExtension(
478 VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 2)) {
479 if (nullptr == fFunctions.fGetAndroidHardwareBufferProperties ||
480 nullptr == fFunctions.fGetMemoryAndroidHardwareBuffer) {
481 RETURN_FALSE_INTERFACE
482 }
483 }
484#endif
485
486 return true;
487}
488
489} // namespace skgpu
490
ACQUIRE_PROC
#define ACQUIRE_PROC(name, instance, device)
Definition VulkanInterface.cpp:13
ACQUIRE_PROC_SUFFIX
#define ACQUIRE_PROC_SUFFIX(name, suffix, instance, device)
Definition VulkanInterface.cpp:16
RETURN_FALSE_INTERFACE
#define RETURN_FALSE_INTERFACE
Definition VulkanInterface.cpp:264
device
VkDevice device
Definition main.cc:53
instance
VkInstance instance
Definition main.cc:48
gen_manifest.extensions
extensions
Definition gen_manifest.py:28
skgpu::kIsDebug
constexpr int kIsDebug
Definition VulkanInterface.cpp:261
VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME
#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME
Definition vulkan_android.h:50
VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME
#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME
Definition vulkan_core.h:8673
VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME
#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME
Definition vulkan_core.h:9443
VK_KHR_MAINTENANCE3_EXTENSION_NAME
#define VK_KHR_MAINTENANCE3_EXTENSION_NAME
Definition vulkan_core.h:9508
VK_MAKE_VERSION
#define VK_MAKE_VERSION(major, minor, patch)
Definition vulkan_core.h:78
VK_KHR_MAINTENANCE1_EXTENSION_NAME
#define VK_KHR_MAINTENANCE1_EXTENSION_NAME
Definition vulkan_core.h:8638
VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME
#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME
Definition vulkan_core.h:9396
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME
#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME
Definition vulkan_core.h:8511
VK_EXT_DEVICE_FAULT_EXTENSION_NAME
#define VK_EXT_DEVICE_FAULT_EXTENSION_NAME
Definition vulkan_core.h:15487
VK_KHR_BIND_MEMORY_2_EXTENSION_NAME
#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME
Definition vulkan_core.h:9482
VK_NULL_HANDLE
#define VK_NULL_HANDLE
Definition vulkan_core.h:46
CreateEvent
#define CreateEvent
Definition windows_types.h:250

◆ ACQUIRE_PROC_SUFFIX

#define ACQUIRE_PROC_SUFFIX (   name,
  suffix,
  instance,
  device 
)
Value:
fFunctions.f##name = \
reinterpret_cast<PFN_vk##name##suffix>(getProc("vk" #name #suffix, instance, device))
name
const char * name
Definition fuchsia.cc:50

Definition at line 16 of file VulkanInterface.cpp.

◆ RETURN_FALSE_INTERFACE

#define RETURN_FALSE_INTERFACE
Value:
if (kIsDebug) { SkDebugf("%s:%d VulkanInterface::validate() failed.\n", __FILE__, __LINE__); } \
return false;
SkDebugf
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1

Definition at line 264 of file VulkanInterface.cpp.

265 { SkDebugf("%s:%d VulkanInterface::validate() failed.\n", __FILE__, __LINE__); } \
266 return false;
Generated on Fri Apr 26 2024 06:18:47 for Flutter Engine by doxygen 1.9.8