Blame - src/gpu/vk/GrVkInterface.cpp - platform/external/skia

2016-02-22 09:56:40 -0500

[diff] [blame]

/*

*

* Use of this source code is governed by a BSD-style license that can be

5

* found in the LICENSE file.

6

*/

7

Greg Daniel

d3e65aa

2018-08-01 09:19:45 -0400

[diff] [blame]

8

#include "GrVkInterface.h"

jvanverth

fd7bd45

2016-03-25 06:29:52 -0700

[diff] [blame]

9

#include "vk/GrVkBackendContext.h"

Greg Daniel

a31f4e5

2018-08-01 16:48:52 -0400

[diff] [blame]

10

#include "vk/GrVkExtensions.h"

jvanverth

d2497f3

2016-03-18 12:39:05 -0700

[diff] [blame]

11

#include "vk/GrVkUtil.h"

Greg Daniel

2016-02-22 09:56:40 -0500

[diff] [blame]

12

Michael Jurka

2017-04-05 09:52:55 -0700

[diff] [blame]

13

#define ACQUIRE_PROC(name, instance, device) fFunctions.f##name = \

14

reinterpret_cast<PFN_vk##name>(getProc("vk"#name, instance, device));

Greg Daniel

2016-02-22 09:56:40 -0500

[diff] [blame]

15

Greg Daniel

2018-08-03 14:41:15 -0400

[diff] [blame]

16

#define ACQUIRE_PROC_SUFFIX(name, suffix, instance, device) fFunctions.f##name = \

17

reinterpret_cast<PFN_vk##name##suffix>(getProc("vk"#name#suffix, instance, device));

18

Greg Daniel

d3e65aa

2018-08-01 09:19:45 -0400

[diff] [blame]

19

GrVkInterface::GrVkInterface(GrVkGetProc getProc,

Michael Jurka

2017-04-05 09:52:55 -0700

[diff] [blame]

20

VkInstance instance,

21

VkDevice device,

Greg Daniel

2018-08-03 14:41:15 -0400

[diff] [blame]

22

uint32_t instanceVersion,

23

uint32_t physicalDeviceVersion,

Greg Daniel

98bffae

2018-08-01 13:25:41 -0400

[diff] [blame]

24

const GrVkExtensions* extensions) {

Michael Jurka

2017-04-05 09:52:55 -0700

[diff] [blame]

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);

Greg Daniel

2016-02-22 09:56:40 -0500

[diff] [blame]

32

Michael Jurka

2017-04-05 09:52:55 -0700

[diff] [blame]

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);

Greg Daniel

2016-02-22 09:56:40 -0500

[diff] [blame]

47

Michael Jurka

2017-04-05 09:52:55 -0700

[diff] [blame]

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);

Greg Daniel

2018-08-03 14:41:15 -0400

[diff] [blame]

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,

VK_NULL_HANDLE);

}

// 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

Greg Daniel

637c06a

2018-09-12 09:44:25 -0400

[diff] [blame]

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

Greg Daniel

2018-08-03 14:41:15 -0400

[diff] [blame]

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

}

Greg Daniel

2018-08-27 15:56:46 -0400

[diff] [blame]

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,

VK_NULL_HANDLE);

}

Greg Daniel

2018-10-18 15:56:00 -0400

[diff] [blame^]

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

Greg Daniel

2018-08-27 15:56:46 -0400

[diff] [blame]

241

#ifdef SK_BUILD_FOR_ANDROID

242

// Functions for VK_ANDROID_external_memory_android_hardware_buffer

243

if (extensions->hasExtension(

Greg Daniel

637c06a

2018-09-12 09:44:25 -0400

[diff] [blame]

244

VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 2)) {

Greg Daniel

2018-08-27 15:56:46 -0400

[diff] [blame]

245

ACQUIRE_PROC_SUFFIX(GetAndroidHardwareBufferProperties, ANDROID, VK_NULL_HANDLE, device);

246

ACQUIRE_PROC_SUFFIX(GetMemoryAndroidHardwareBuffer, ANDROID, VK_NULL_HANDLE, device);

}

#endif

Greg Daniel

2016-02-22 09:56:40 -0500

[diff] [blame]

250

}

251

Greg Daniel

fe2965a

2016-10-11 16:31:05 -0400

[diff] [blame]

252

#ifdef SK_DEBUG

253

static int kIsDebug = 1;

254

#else

255

static int kIsDebug = 0;

256

#endif

257

Greg Daniel

2016-02-22 09:56:40 -0500

[diff] [blame]

258

#define RETURN_FALSE_INTERFACE \

259

if (kIsDebug) { SkDebugf("%s:%d GrVkInterface::validate() failed.\n", __FILE__, __LINE__); } \

260

return false;

261

Greg Daniel

2018-08-03 14:41:15 -0400

[diff] [blame]

262

bool GrVkInterface::validate(uint32_t instanceVersion, uint32_t physicalDeviceVersion,

263

const GrVkExtensions* extensions) const {

Greg Daniel

2016-02-22 09:56:40 -0500

[diff] [blame]

264

// functions that are always required

Ben Wagner

a93a14a

2017-08-28 10:34:05 -0400

[diff] [blame]

265

if (nullptr == fFunctions.fCreateInstance ||

266

nullptr == fFunctions.fDestroyInstance ||

267

nullptr == fFunctions.fEnumeratePhysicalDevices ||

268

nullptr == fFunctions.fGetPhysicalDeviceFeatures ||

269

nullptr == fFunctions.fGetPhysicalDeviceFormatProperties ||

270

nullptr == fFunctions.fGetPhysicalDeviceImageFormatProperties ||

271

nullptr == fFunctions.fGetPhysicalDeviceProperties ||

272

nullptr == fFunctions.fGetPhysicalDeviceQueueFamilyProperties ||

273

nullptr == fFunctions.fGetPhysicalDeviceMemoryProperties ||

274

nullptr == fFunctions.fCreateDevice ||

275

nullptr == fFunctions.fDestroyDevice ||

276

nullptr == fFunctions.fEnumerateInstanceExtensionProperties ||

277

nullptr == fFunctions.fEnumerateDeviceExtensionProperties ||

278

nullptr == fFunctions.fEnumerateInstanceLayerProperties ||

279

nullptr == fFunctions.fEnumerateDeviceLayerProperties ||

280

nullptr == fFunctions.fGetDeviceQueue ||

281

nullptr == fFunctions.fQueueSubmit ||

282

nullptr == fFunctions.fQueueWaitIdle ||

283

nullptr == fFunctions.fDeviceWaitIdle ||

284

nullptr == fFunctions.fAllocateMemory ||

285

nullptr == fFunctions.fFreeMemory ||

286

nullptr == fFunctions.fMapMemory ||

287

nullptr == fFunctions.fUnmapMemory ||

288

nullptr == fFunctions.fFlushMappedMemoryRanges ||

289

nullptr == fFunctions.fInvalidateMappedMemoryRanges ||

290

nullptr == fFunctions.fGetDeviceMemoryCommitment ||

291

nullptr == fFunctions.fBindBufferMemory ||

292

nullptr == fFunctions.fBindImageMemory ||

293

nullptr == fFunctions.fGetBufferMemoryRequirements ||

294

nullptr == fFunctions.fGetImageMemoryRequirements ||

295

nullptr == fFunctions.fGetImageSparseMemoryRequirements ||

296

nullptr == fFunctions.fGetPhysicalDeviceSparseImageFormatProperties ||

297

nullptr == fFunctions.fQueueBindSparse ||

298

nullptr == fFunctions.fCreateFence ||

299

nullptr == fFunctions.fDestroyFence ||

300

nullptr == fFunctions.fResetFences ||

301

nullptr == fFunctions.fGetFenceStatus ||

302

nullptr == fFunctions.fWaitForFences ||

303

nullptr == fFunctions.fCreateSemaphore ||

304

nullptr == fFunctions.fDestroySemaphore ||

305

nullptr == fFunctions.fCreateEvent ||

306

nullptr == fFunctions.fDestroyEvent ||

307

nullptr == fFunctions.fGetEventStatus ||

308

nullptr == fFunctions.fSetEvent ||

309

nullptr == fFunctions.fResetEvent ||

310

nullptr == fFunctions.fCreateQueryPool ||

311

nullptr == fFunctions.fDestroyQueryPool ||

312

nullptr == fFunctions.fGetQueryPoolResults ||

313

nullptr == fFunctions.fCreateBuffer ||

314

nullptr == fFunctions.fDestroyBuffer ||

315

nullptr == fFunctions.fCreateBufferView ||

316

nullptr == fFunctions.fDestroyBufferView ||

317

nullptr == fFunctions.fCreateImage ||

318

nullptr == fFunctions.fDestroyImage ||

319

nullptr == fFunctions.fGetImageSubresourceLayout ||

320

nullptr == fFunctions.fCreateImageView ||

321

nullptr == fFunctions.fDestroyImageView ||

322

nullptr == fFunctions.fCreateShaderModule ||

323

nullptr == fFunctions.fDestroyShaderModule ||

324

nullptr == fFunctions.fCreatePipelineCache ||

325

nullptr == fFunctions.fDestroyPipelineCache ||

326

nullptr == fFunctions.fGetPipelineCacheData ||

327

nullptr == fFunctions.fMergePipelineCaches ||

328

nullptr == fFunctions.fCreateGraphicsPipelines ||

329

nullptr == fFunctions.fCreateComputePipelines ||

330

nullptr == fFunctions.fDestroyPipeline ||

331

nullptr == fFunctions.fCreatePipelineLayout ||

332

nullptr == fFunctions.fDestroyPipelineLayout ||

333

nullptr == fFunctions.fCreateSampler ||

334

nullptr == fFunctions.fDestroySampler ||

335

nullptr == fFunctions.fCreateDescriptorSetLayout ||

336

nullptr == fFunctions.fDestroyDescriptorSetLayout ||

337

nullptr == fFunctions.fCreateDescriptorPool ||

338

nullptr == fFunctions.fDestroyDescriptorPool ||

339

nullptr == fFunctions.fResetDescriptorPool ||

340

nullptr == fFunctions.fAllocateDescriptorSets ||

341

nullptr == fFunctions.fFreeDescriptorSets ||

342

nullptr == fFunctions.fUpdateDescriptorSets ||

343

nullptr == fFunctions.fCreateFramebuffer ||

344

nullptr == fFunctions.fDestroyFramebuffer ||

345

nullptr == fFunctions.fCreateRenderPass ||

346

nullptr == fFunctions.fDestroyRenderPass ||

347

nullptr == fFunctions.fGetRenderAreaGranularity ||

348

nullptr == fFunctions.fCreateCommandPool ||

349

nullptr == fFunctions.fDestroyCommandPool ||

350

nullptr == fFunctions.fResetCommandPool ||

351

nullptr == fFunctions.fAllocateCommandBuffers ||

352

nullptr == fFunctions.fFreeCommandBuffers ||

353

nullptr == fFunctions.fBeginCommandBuffer ||

354

nullptr == fFunctions.fEndCommandBuffer ||

355

nullptr == fFunctions.fResetCommandBuffer ||

356

nullptr == fFunctions.fCmdBindPipeline ||

357

nullptr == fFunctions.fCmdSetViewport ||

358

nullptr == fFunctions.fCmdSetScissor ||

359

nullptr == fFunctions.fCmdSetLineWidth ||

360

nullptr == fFunctions.fCmdSetDepthBias ||

361

nullptr == fFunctions.fCmdSetBlendConstants ||

362

nullptr == fFunctions.fCmdSetDepthBounds ||

363

nullptr == fFunctions.fCmdSetStencilCompareMask ||

364

nullptr == fFunctions.fCmdSetStencilWriteMask ||

365

nullptr == fFunctions.fCmdSetStencilReference ||

366

nullptr == fFunctions.fCmdBindDescriptorSets ||

367

nullptr == fFunctions.fCmdBindIndexBuffer ||

368

nullptr == fFunctions.fCmdBindVertexBuffers ||

369

nullptr == fFunctions.fCmdDraw ||

370

nullptr == fFunctions.fCmdDrawIndexed ||

371

nullptr == fFunctions.fCmdDrawIndirect ||

372

nullptr == fFunctions.fCmdDrawIndexedIndirect ||

373

nullptr == fFunctions.fCmdDispatch ||

374

nullptr == fFunctions.fCmdDispatchIndirect ||

375

nullptr == fFunctions.fCmdCopyBuffer ||

376

nullptr == fFunctions.fCmdCopyImage ||

377

nullptr == fFunctions.fCmdBlitImage ||

378

nullptr == fFunctions.fCmdCopyBufferToImage ||

379

nullptr == fFunctions.fCmdCopyImageToBuffer ||

380

nullptr == fFunctions.fCmdUpdateBuffer ||

381

nullptr == fFunctions.fCmdFillBuffer ||

382

nullptr == fFunctions.fCmdClearColorImage ||

383

nullptr == fFunctions.fCmdClearDepthStencilImage ||

384

nullptr == fFunctions.fCmdClearAttachments ||

385

nullptr == fFunctions.fCmdResolveImage ||

386

nullptr == fFunctions.fCmdSetEvent ||

387

nullptr == fFunctions.fCmdResetEvent ||

388

nullptr == fFunctions.fCmdWaitEvents ||

389

nullptr == fFunctions.fCmdPipelineBarrier ||

390

nullptr == fFunctions.fCmdBeginQuery ||

391

nullptr == fFunctions.fCmdEndQuery ||

392

nullptr == fFunctions.fCmdResetQueryPool ||

393

nullptr == fFunctions.fCmdWriteTimestamp ||

394

nullptr == fFunctions.fCmdCopyQueryPoolResults ||

395

nullptr == fFunctions.fCmdPushConstants ||

396

nullptr == fFunctions.fCmdBeginRenderPass ||

397

nullptr == fFunctions.fCmdNextSubpass ||

398

nullptr == fFunctions.fCmdEndRenderPass ||

399

nullptr == fFunctions.fCmdExecuteCommands) {

Greg Daniel

fe2965a

2016-10-11 16:31:05 -0400

[diff] [blame]

400

RETURN_FALSE_INTERFACE

401

}

jvanverth

e50f3e7

2016-03-28 07:03:06 -0700

[diff] [blame]

402

Greg Daniel

2018-08-03 14:41:15 -0400

[diff] [blame]

403

// Functions for VK_KHR_get_physical_device_properties2 or vulkan 1.1

404

if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||

405

extensions->hasExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1)) {

406

if (nullptr == fFunctions.fGetPhysicalDeviceFeatures2 ||

407

nullptr == fFunctions.fGetPhysicalDeviceProperties2 ||

408

nullptr == fFunctions.fGetPhysicalDeviceFormatProperties2 ||

409

nullptr == fFunctions.fGetPhysicalDeviceImageFormatProperties2 ||

410

nullptr == fFunctions.fGetPhysicalDeviceQueueFamilyProperties2 ||

411

nullptr == fFunctions.fGetPhysicalDeviceMemoryProperties2 ||

412

nullptr == fFunctions.fGetPhysicalDeviceSparseImageFormatProperties2) {

413

RETURN_FALSE_INTERFACE

}

}

// Functions for VK_KHR_get_memory_requirements2 or vulkan 1.1

418

if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||

419

extensions->hasExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1)) {

420

if (nullptr == fFunctions.fGetImageMemoryRequirements2 ||

421

nullptr == fFunctions.fGetBufferMemoryRequirements2 ||

422

nullptr == fFunctions.fGetImageSparseMemoryRequirements2) {

423

RETURN_FALSE_INTERFACE

}

}

Greg Daniel

2018-09-12 09:44:25 -0400

[diff] [blame]

427

// Functions for VK_KHR_bind_memory2

428

if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||

429

extensions->hasExtension(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, 1)) {

430

if (nullptr == fFunctions.fBindBufferMemory2 ||

431

nullptr == fFunctions.fBindImageMemory2) {

432

RETURN_FALSE_INTERFACE

}

}

Greg Daniel

2018-08-03 14:41:15 -0400

[diff] [blame]

436

// Functions for VK_KHR_maintenance1 or vulkan 1.1

437

if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||

438

extensions->hasExtension(VK_KHR_MAINTENANCE1_EXTENSION_NAME, 1)) {

439

if (nullptr == fFunctions.fTrimCommandPool) {

440

RETURN_FALSE_INTERFACE

}

}

// Functions for VK_KHR_maintenance3 or vulkan 1.1

445

if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||

446

extensions->hasExtension(VK_KHR_MAINTENANCE3_EXTENSION_NAME, 1)) {

447

if (nullptr == fFunctions.fGetDescriptorSetLayoutSupport) {

448

RETURN_FALSE_INTERFACE

}

}

Greg Daniel

2018-08-27 15:56:46 -0400

[diff] [blame]

452

// Functions for VK_KHR_external_memory_capabilities

453

if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||

454

extensions->hasExtension(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1)) {

455

if (nullptr == fFunctions.fGetPhysicalDeviceExternalBufferProperties) {

456

RETURN_FALSE_INTERFACE

}

}

Greg Daniel

2018-10-18 15:56:00 -0400

[diff] [blame^]

460

// Functions for VK_KHR_sampler_ycbcr_conversion

461

if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||

462

extensions->hasExtension(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, 1)) {

463

if (nullptr == fFunctions.fCreateSamplerYcbcrConversion ||

464

nullptr == fFunctions.fDestroySamplerYcbcrConversion) {

465

RETURN_FALSE_INTERFACE

}

}

Greg Daniel

2018-08-27 15:56:46 -0400

[diff] [blame]

469

#ifdef SK_BUILD_FOR_ANDROID

470

// Functions for VK_ANDROID_external_memory_android_hardware_buffer

471

if (extensions->hasExtension(

Greg Daniel

637c06a

2018-09-12 09:44:25 -0400

[diff] [blame]

472

VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 2)) {

Greg Daniel