sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

VulkanRenderer: Move vulkan wrappers to a separate directory

Browse Source
This commit is contained in:
Lynix
2016-10-29 01:59:06 +02:00
parent 8d06c57d0d
commit e61c6d0a8e
58 changed files with 108 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
src/Nazara/VulkanRenderer/Wrapper/CommandPool.cpp Normal file
View File

@@ -0,0 +1,53 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Vulkan Renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/Wrapper/CommandPool.hpp>
#include <Nazara/VulkanRenderer/Wrapper/CommandBuffer.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
{
namespace Vk
{
CommandBuffer CommandPool::AllocateCommandBuffer(VkCommandBufferLevel level)
{
VkCommandBufferAllocateInfo createInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
nullptr,
m_handle,
level,
1U
};
VkCommandBuffer handle = VK_NULL_HANDLE;
m_lastErrorCode = m_device->vkAllocateCommandBuffers(*m_device, &createInfo, &handle);
return CommandBuffer(*this, handle);
}
std::vector<CommandBuffer> CommandPool::AllocateCommandBuffers(UInt32 commandBufferCount, VkCommandBufferLevel level)
{
VkCommandBufferAllocateInfo createInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
nullptr,
m_handle,
level,
commandBufferCount
};
std::vector<VkCommandBuffer> handles(commandBufferCount, VK_NULL_HANDLE);
m_lastErrorCode = m_device->vkAllocateCommandBuffers(*m_device, &createInfo, handles.data());
if (m_lastErrorCode != VkResult::VK_SUCCESS)
return std::vector<CommandBuffer>();
std::vector<CommandBuffer> commandBuffers;
for (UInt32 i = 0; i < commandBufferCount; ++i)
commandBuffers.emplace_back(CommandBuffer(*this, handles[i]));
return commandBuffers;
}
}
}

53
src/Nazara/VulkanRenderer/Wrapper/DescriptorPool.cpp Normal file
View File

@@ -0,0 +1,53 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Vulkan Renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/Wrapper/DescriptorPool.hpp>
#include <Nazara/VulkanRenderer/Wrapper/DescriptorSet.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
{
namespace Vk
{
DescriptorSet DescriptorPool::AllocateDescriptorSet(const VkDescriptorSetLayout& setLayouts)
{
VkDescriptorSetAllocateInfo createInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
nullptr, // const void* pNext;
m_handle, // VkDescriptorPool descriptorPool;
1U, // uint32_t descriptorSetCount;
&setLayouts // const VkDescriptorSetLayout* pSetLayouts;
};
VkDescriptorSet handle = VK_NULL_HANDLE;
m_lastErrorCode = m_device->vkAllocateDescriptorSets(*m_device, &createInfo, &handle);
return DescriptorSet(*this, handle);
}
std::vector<DescriptorSet> DescriptorPool::AllocateDescriptorSets(UInt32 descriptorSetCount, const VkDescriptorSetLayout* setLayouts)
{
VkDescriptorSetAllocateInfo createInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
nullptr, // const void* pNext;
m_handle, // VkDescriptorPool descriptorPool;
descriptorSetCount, // uint32_t descriptorSetCount;
setLayouts // const VkDescriptorSetLayout* pSetLayouts;
};
std::vector<VkDescriptorSet> handles(descriptorSetCount, VK_NULL_HANDLE);
m_lastErrorCode = m_device->vkAllocateDescriptorSets(*m_device, &createInfo, handles.data());
if (m_lastErrorCode != VkResult::VK_SUCCESS)
return std::vector<DescriptorSet>();
std::vector<DescriptorSet> descriptorSets;
for (UInt32 i = 0; i < descriptorSetCount; ++i)
descriptorSets.emplace_back(DescriptorSet(*this, handles[i]));
return descriptorSets;
}
}
}

222
src/Nazara/VulkanRenderer/Wrapper/Device.cpp Normal file
View File

@@ -0,0 +1,222 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Vulkan Renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/Wrapper/Device.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/ErrorFlags.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
{
namespace Vk
{
bool Device::Create(VkPhysicalDevice device, const VkDeviceCreateInfo& createInfo, const VkAllocationCallbacks* allocator)
{
std::vector<VkQueueFamilyProperties> queuesProperties;
if (!m_instance.GetPhysicalDeviceQueueFamilyProperties(device, &queuesProperties))
{
NazaraError("Failed to query queue family properties");
return false;
}
m_lastErrorCode = m_instance.vkCreateDevice(device, &createInfo, allocator, &m_device);
if (m_lastErrorCode != VkResult::VK_SUCCESS)
{
NazaraError("Failed to create Vulkan device");
return false;
}
m_physicalDevice = device;
// Store the allocator to access them when needed
if (allocator)
m_allocator = *allocator;
else
m_allocator.pfnAllocation = nullptr;
// Parse extensions and layers
for (UInt32 i = 0; i < createInfo.enabledExtensionCount; ++i)
m_loadedExtensions.insert(createInfo.ppEnabledExtensionNames[i]);
for (UInt32 i = 0; i < createInfo.enabledLayerCount; ++i)
m_loadedLayers.insert(createInfo.ppEnabledLayerNames[i]);
// Load all device-related functions
#define NAZARA_VULKANRENDERER_LOAD_DEVICE(func) func = reinterpret_cast<PFN_##func>(GetProcAddr(#func))
try
{
ErrorFlags flags(ErrorFlag_ThrowException, true);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkAllocateCommandBuffers);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkAllocateDescriptorSets);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkAllocateMemory);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkBeginCommandBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkBindBufferMemory);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkBindImageMemory);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdBeginQuery);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdBeginRenderPass);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdBindDescriptorSets);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdBindIndexBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdBindPipeline);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdBindVertexBuffers);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdBlitImage);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdClearAttachments);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdClearColorImage);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdClearDepthStencilImage);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdCopyBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdCopyBufferToImage);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdCopyImage);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdCopyImageToBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdCopyQueryPoolResults);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdDispatch);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdDispatchIndirect);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdDraw);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdDrawIndexed);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdDrawIndexedIndirect);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdDrawIndirect);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdEndQuery);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdEndRenderPass);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdExecuteCommands);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdFillBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdNextSubpass);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdPipelineBarrier);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdPushConstants);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdResetEvent);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdResetQueryPool);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdResolveImage);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetBlendConstants);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetDepthBias);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetDepthBounds);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetEvent);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetLineWidth);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetScissor);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetStencilCompareMask);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetStencilReference);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetStencilWriteMask);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdSetViewport);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdUpdateBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdWaitEvents);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCmdWriteTimestamp);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateBufferView);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateCommandPool);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateComputePipelines);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateDescriptorPool);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateDescriptorSetLayout);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateEvent);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateFramebuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateGraphicsPipelines);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateImage);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateImageView);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreatePipelineCache);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreatePipelineLayout);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateRenderPass);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateSampler);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateSemaphore);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateShaderModule);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyBufferView);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyCommandPool);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyDescriptorPool);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyDescriptorSetLayout);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyDevice);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyEvent);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyFramebuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyImage);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyImageView);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyPipeline);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyPipelineCache);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyPipelineLayout);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyRenderPass);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroySampler);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroySemaphore);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroyShaderModule);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDeviceWaitIdle);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkEndCommandBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkFreeCommandBuffers);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkFreeDescriptorSets);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkFreeMemory);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkFlushMappedMemoryRanges);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetBufferMemoryRequirements);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetDeviceMemoryCommitment);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetDeviceQueue);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetEventStatus);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetFenceStatus);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetImageMemoryRequirements);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetImageSparseMemoryRequirements);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetImageSubresourceLayout);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetRenderAreaGranularity);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkInvalidateMappedMemoryRanges);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkMapMemory);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkMergePipelineCaches);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkQueueSubmit);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkQueueWaitIdle);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkResetCommandBuffer);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkResetCommandPool);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkResetDescriptorPool);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkResetFences);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkResetEvent);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkSetEvent);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkUnmapMemory);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkUpdateDescriptorSets);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkWaitForFences);
// VK_KHR_display_swapchain
if (IsExtensionLoaded("VK_KHR_display_swapchain"))
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateSharedSwapchainsKHR);
// VK_KHR_swapchain
if (IsExtensionLoaded("VK_KHR_swapchain"))
{
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkAcquireNextImageKHR);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkCreateSwapchainKHR);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkDestroySwapchainKHR);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkGetSwapchainImagesKHR);
NAZARA_VULKANRENDERER_LOAD_DEVICE(vkQueuePresentKHR);
}
}
catch (const std::exception& e)
{
NazaraError(String("Failed to query device function: ") + e.what());
return false;
}
#undef NAZARA_VULKANRENDERER_LOAD_DEVICE
// And retains informations about queues
UInt32 maxFamilyIndex = 0;
m_enabledQueuesInfos.resize(createInfo.queueCreateInfoCount);
for (UInt32 i = 0; i < createInfo.queueCreateInfoCount; ++i)
{
const VkDeviceQueueCreateInfo& queueCreateInfo = createInfo.pQueueCreateInfos[i];
QueueFamilyInfo& info = m_enabledQueuesInfos[i];
info.familyIndex = queueCreateInfo.queueFamilyIndex;
if (info.familyIndex > maxFamilyIndex)
maxFamilyIndex = info.familyIndex;
const VkQueueFamilyProperties& queueProperties = queuesProperties[info.familyIndex];
info.flags = queueProperties.queueFlags;
info.minImageTransferGranularity = queueProperties.minImageTransferGranularity;
info.timestampValidBits = queueProperties.timestampValidBits;
info.queues.resize(queueCreateInfo.queueCount);
for (UInt32 queueIndex = 0; queueIndex < queueCreateInfo.queueCount; ++queueIndex)
{
QueueInfo& queueInfo = info.queues[queueIndex];
queueInfo.familyInfo = &info;
queueInfo.priority = queueCreateInfo.pQueuePriorities[queueIndex];
vkGetDeviceQueue(m_device, info.familyIndex, queueIndex, &queueInfo.queue);
}
}
m_queuesByFamily.resize(maxFamilyIndex + 1);
for (const QueueFamilyInfo& familyInfo : m_enabledQueuesInfos)
m_queuesByFamily[familyInfo.familyIndex] = &familyInfo.queues;
return true;
}
}
}

194
src/Nazara/VulkanRenderer/Wrapper/Instance.cpp Normal file
View File

@@ -0,0 +1,194 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Vulkan Renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/Wrapper/Instance.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/ErrorFlags.hpp>
#include <Nazara/VulkanRenderer/Utils.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
{
namespace Vk
{
bool Instance::Create(const VkInstanceCreateInfo& createInfo, const VkAllocationCallbacks* allocator)
{
m_lastErrorCode = Loader::vkCreateInstance(&createInfo, allocator, &m_instance);
if (m_lastErrorCode != VkResult::VK_SUCCESS)
{
NazaraError("Failed to create Vulkan instance");
return false;
}
// Store the allocator to access them when needed
if (allocator)
m_allocator = *allocator;
else
m_allocator.pfnAllocation = nullptr;
// Parse extensions and layers
for (UInt32 i = 0; i < createInfo.enabledExtensionCount; ++i)
m_loadedExtensions.insert(createInfo.ppEnabledExtensionNames[i]);
for (UInt32 i = 0; i < createInfo.enabledLayerCount; ++i)
m_loadedLayers.insert(createInfo.ppEnabledLayerNames[i]);
// And now load everything
#define NAZARA_VULKANRENDERER_LOAD_INSTANCE(func) func = reinterpret_cast<PFN_##func>(GetProcAddr(#func))
try
{
ErrorFlags flags(ErrorFlag_ThrowException, true);
// Vulkan core
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateDevice);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkDestroyInstance);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkEnumeratePhysicalDevices);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetDeviceProcAddr);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceFeatures);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceFormatProperties);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceImageFormatProperties);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceMemoryProperties);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceProperties);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceQueueFamilyProperties);
// VK_KHR_display
if (IsExtensionLoaded("VK_KHR_display"))
{
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateDisplayModeKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateDisplayPlaneSurfaceKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetDisplayModePropertiesKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetDisplayPlaneCapabilitiesKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetDisplayPlaneSupportedDisplaysKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceDisplayPropertiesKHR);
}
// VK_KHR_surface
if (IsExtensionLoaded("VK_KHR_surface"))
{
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkDestroySurfaceKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceSurfaceFormatsKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceSurfacePresentModesKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceSurfaceSupportKHR);
}
// VK_EXT_debug_report
if (IsExtensionLoaded("VK_EXT_debug_report"))
{
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateDebugReportCallbackEXT);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkDestroyDebugReportCallbackEXT);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkDebugReportMessageEXT);
}
#ifdef VK_USE_PLATFORM_ANDROID_KHR
// VK_KHR_android_surface
if (IsExtensionLoaded("VK_KHR_android_surface"))
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateAndroidSurfaceKHR);
#endif
#ifdef VK_USE_PLATFORM_MIR_KHR
// VK_KHR_mir_surface
if (IsExtensionLoaded("VK_KHR_mir_surface"))
{
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateMirSurfaceKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceMirPresentationSupportKHR);
}
#endif
#ifdef VK_USE_PLATFORM_XCB_KHR
// VK_KHR_xcb_surface
if (IsExtensionLoaded("VK_KHR_xcb_surface"))
{
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateXcbSurfaceKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceXcbPresentationSupportKHR);
}
#endif
#ifdef VK_USE_PLATFORM_XLIB_KHR
// VK_KHR_xlib_surface
if (IsExtensionLoaded("VK_KHR_xlib_surface"))
{
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateXlibSurfaceKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceXlibPresentationSupportKHR);
}
#endif
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
// VK_KHR_wayland_surface
if (IsExtensionLoaded("VK_KHR_wayland_surface"))
{
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateWaylandSurfaceKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceWaylandPresentationSupportKHR);
}
#endif
#ifdef VK_USE_PLATFORM_WIN32_KHR
// VK_KHR_win32_surface
if (IsExtensionLoaded("VK_KHR_win32_surface"))
{
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkCreateWin32SurfaceKHR);
NAZARA_VULKANRENDERER_LOAD_INSTANCE(vkGetPhysicalDeviceWin32PresentationSupportKHR);
}
#endif
}
catch (const std::exception& e)
{
NazaraError(String("Failed to query instance function: ") + e.what());
return false;
}
#undef NAZARA_VULKANRENDERER_LOAD_INSTANCE
return true;
}
bool Instance::EnumeratePhysicalDevices(std::vector<VkPhysicalDevice>* devices)
{
NazaraAssert(devices, "Invalid device vector");
// First, query physical device count
UInt32 deviceCount = 0; // Remember, Nz::UInt32 is a typedef on uint32_t
m_lastErrorCode = vkEnumeratePhysicalDevices(m_instance, &deviceCount, nullptr);
if (m_lastErrorCode != VkResult::VK_SUCCESS || deviceCount == 0)
{
NazaraError("Failed to query physical device count: " + TranslateVulkanError(m_lastErrorCode));
return false;
}
// Now we can get the list of the available physical device
devices->resize(deviceCount);
m_lastErrorCode = vkEnumeratePhysicalDevices(m_instance, &deviceCount, devices->data());
if (m_lastErrorCode != VkResult::VK_SUCCESS)
{
NazaraError("Failed to query physical devices: " + TranslateVulkanError(m_lastErrorCode));
return false;
}
return true;
}
bool Instance::GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice device, std::vector<VkQueueFamilyProperties>* queueFamilyProperties)
{
NazaraAssert(queueFamilyProperties, "Invalid device vector");
// First, query physical device count
UInt32 queueFamiliesCount = 0; // Remember, Nz::UInt32 is a typedef on uint32_t
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamiliesCount, nullptr);
if (queueFamiliesCount == 0)
{
NazaraError("Failed to query physical device count");
return false;
}
// Now we can get the list of the available physical device
queueFamilyProperties->resize(queueFamiliesCount);
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamiliesCount, queueFamilyProperties->data());
return true;
}
}
}

118
src/Nazara/VulkanRenderer/Wrapper/Loader.cpp Normal file
View File

@@ -0,0 +1,118 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Vulkan Renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/Wrapper/Loader.hpp>
#include <Nazara/VulkanRenderer/Utils.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
{
namespace Vk
{
bool Loader::EnumerateInstanceExtensionProperties(std::vector<VkExtensionProperties>* properties, const char* layerName)
{
NazaraAssert(properties, "Invalid device vector");
// First, query physical device count
UInt32 propertyCount = 0; // Remember, Nz::UInt32 is a typedef on uint32_t
s_lastErrorCode = vkEnumerateInstanceExtensionProperties(layerName, &propertyCount, properties->data());
if (s_lastErrorCode != VkResult::VK_SUCCESS)
{
NazaraError("Failed to get instance extension properties count: " + TranslateVulkanError(s_lastErrorCode));
return false;
}
// Now we can get the list of the available physical device
properties->resize(propertyCount);
s_lastErrorCode = vkEnumerateInstanceExtensionProperties(layerName, &propertyCount, properties->data());
if (s_lastErrorCode != VkResult::VK_SUCCESS)
{
NazaraError("Failed to enumerate instance extension properties: " + TranslateVulkanError(s_lastErrorCode));
return false;
}
return true;
}
bool Loader::EnumerateInstanceLayerProperties(std::vector<VkLayerProperties>* properties)
{
NazaraAssert(properties, "Invalid device vector");
// First, query physical device count
UInt32 propertyCount = 0; // Remember, Nz::UInt32 is a typedef on uint32_t
s_lastErrorCode = vkEnumerateInstanceLayerProperties(&propertyCount, properties->data());
if (s_lastErrorCode != VkResult::VK_SUCCESS)
{
NazaraError("Failed to get instance layer properties count: " + TranslateVulkanError(s_lastErrorCode));
return false;
}
// Now we can get the list of the available physical device
properties->resize(propertyCount);
s_lastErrorCode = vkEnumerateInstanceLayerProperties(&propertyCount, properties->data());
if (s_lastErrorCode != VkResult::VK_SUCCESS)
{
NazaraError("Failed to enumerate instance layer properties: " + TranslateVulkanError(s_lastErrorCode));
return false;
}
return true;
}
bool Loader::Initialize()
{
#ifdef NAZARA_PLATFORM_WINDOWS
s_vulkanLib.Load("vulkan-1.dll");
#elif defined(NAZARA_PLATFORM_LINUX)
s_vulkanLib.Load("libvulkan.so");
#else
#error Unhandled platform
#endif
if (!s_vulkanLib.IsLoaded())
{
NazaraError("Failed to open vulkan library: " + s_vulkanLib.GetLastError());
return false;
}
// vkGetInstanceProcAddr is the only function that's garantee to be exported
vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(s_vulkanLib.GetSymbol("vkGetInstanceProcAddr"));
if (!vkGetInstanceProcAddr)
{
NazaraError("Failed to get symbol \"vkGetInstanceProcAddr\": " + s_vulkanLib.GetLastError());
return false;
}
// all other functions should be loaded using vkGetInstanceProcAddr
#define NAZARA_VULKANRENDERER_LOAD_GLOBAL(func) func = reinterpret_cast<PFN_##func>(vkGetInstanceProcAddr(nullptr, #func))
NAZARA_VULKANRENDERER_LOAD_GLOBAL(vkCreateInstance);
NAZARA_VULKANRENDERER_LOAD_GLOBAL(vkEnumerateInstanceExtensionProperties);
NAZARA_VULKANRENDERER_LOAD_GLOBAL(vkEnumerateInstanceLayerProperties);
#undef NAZARA_VULKANRENDERER_LOAD_GLOBAL
s_lastErrorCode = VkResult::VK_SUCCESS;
return true;
}
#define NAZARA_VULKANRENDERER_GLOBAL_FUNCTION_IMPL(func) PFN_##func Loader::func = nullptr
NAZARA_VULKANRENDERER_GLOBAL_FUNCTION_IMPL(vkCreateInstance);
NAZARA_VULKANRENDERER_GLOBAL_FUNCTION_IMPL(vkEnumerateInstanceExtensionProperties);
NAZARA_VULKANRENDERER_GLOBAL_FUNCTION_IMPL(vkEnumerateInstanceLayerProperties);
NAZARA_VULKANRENDERER_GLOBAL_FUNCTION_IMPL(vkGetInstanceProcAddr);
#undef NAZARA_VULKANRENDERER_GLOBAL_FUNCTION_IMPL
DynLib Loader::s_vulkanLib;
VkResult Loader::s_lastErrorCode;
void Loader::Uninitialize()
{
s_vulkanLib.Unload();
}
}
}