int VulkanContext::GetBestPhysicalDevice() {
// Rules: Prefer discrete over embedded.
// Prefer nVidia over Intel.
int maxScore = -1;
int best = -1;
for (size_t i = 0; i < physical_devices_.size(); i++) {
int score = 0;
VkPhysicalDeviceProperties props;
vkGetPhysicalDeviceProperties(physical_devices_[i], &props);
switch (props.deviceType) {
case VK_PHYSICAL_DEVICE_TYPE_CPU:
score += 1;
break;
case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
score += 20;
break;
case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
score += 10;
break;
}
if (props.vendorID == VULKAN_VENDOR_AMD) {
score += 5;
} else if (props.vendorID == VULKAN_VENDOR_NVIDIA) {
score += 5;
}
if (score > maxScore) {
best = (int)i;
maxScore = score;
}
}
return best;
}
void chose_physical_device()
{
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if(deviceCount == 0)
{
cerr<<"no device with vulkan support found"<<endl;
return;
}
std::vector<VkPhysicalDevice> devices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
if(!select_device(devices, physical_device))
{
cerr<<"no suitable device found"<<endl;
return;
}
VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(physical_device, &deviceProperties);
cout << "chosen device:" << deviceProperties.deviceName << endl;
}
Device::Device(VkPhysicalDevice physicalDevice) : physicalDevice(physicalDevice)
{
// select a queue family with compute support
uint32_t numQueues;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &numQueues, nullptr);
VkQueueFamilyProperties *queueFamilyProperties = new VkQueueFamilyProperties[numQueues];
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &numQueues, queueFamilyProperties);
for (uint32_t i = 0; i < numQueues; i++) {
if (queueFamilyProperties[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
computeQueueFamily = i;
break;
}
}
delete [] queueFamilyProperties;
if (computeQueueFamily == -1) {
throw ERROR_DEVICES;
}
VkDeviceQueueCreateInfo queueCreateInfo = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO};
queueCreateInfo.queueCount = 1;
float priorities[] = {1.0f};
queueCreateInfo.pQueuePriorities = priorities;
queueCreateInfo.queueFamilyIndex = computeQueueFamily;
// create the logical device
VkPhysicalDeviceFeatures physicalDeviceFeatures = {};
VkDeviceCreateInfo deviceCreateInfo = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO};
deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
deviceCreateInfo.pEnabledFeatures = &physicalDeviceFeatures;
deviceCreateInfo.queueCreateInfoCount = 1;
if (VK_SUCCESS != vkCreateDevice(physicalDevice, &deviceCreateInfo, nullptr, &device)) {
throw ERROR_DEVICES;
}
vkGetDeviceQueue(device, computeQueueFamily, 0, &queue);
vkGetPhysicalDeviceProperties(physicalDevice, &physicalDeviceProperties);
// get indices of memory types we care about
VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &physicalDeviceMemoryProperties);
for (uint32_t i = 0; i < physicalDeviceMemoryProperties.memoryTypeCount; i++) {
if (physicalDeviceMemoryProperties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT && memoryTypeMappable == -1) {
memoryTypeMappable = i;
}
if (physicalDeviceMemoryProperties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT && memoryTypeLocal == -1) {
memoryTypeLocal = i;
}
}
// create the implicit command buffer
implicitCommandBuffer = new CommandBuffer(*this);
}
void VulkanContext::PopulateBackendInfoAdapters(VideoConfig* config, const GPUList& gpu_list)
{
config->backend_info.Adapters.clear();
for (VkPhysicalDevice physical_device : gpu_list)
{
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(physical_device, &properties);
config->backend_info.Adapters.push_back(properties.deviceName);
}
}
void getDevicesList()
{
vkEnumeratePhysicalDevices( gInstance, &gDeviceCount, gDevices );
std::cout << "Device list:\n";
for( u32 i = 0; i < gDeviceCount; ++i )
{
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties( gDevices[i], &properties );
std::cout << "\t" << properties.deviceName << std::endl;
}
}
void ProfilerVK::init(VkDevice device, VkPhysicalDevice physicalDevice, const VkAllocationCallbacks* allocator)
{
m_device = device;
m_allocator = allocator;
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(physicalDevice, &properties);
m_frequency = properties.limits.timestampPeriod;
resize();
}
void Renderer::_InitDevice()
{
{
uint32_t gpu_count = 0;
vkEnumeratePhysicalDevices( _instance, &gpu_count, nullptr );
std::vector<VkPhysicalDevice> gpu_list( gpu_count );
vkEnumeratePhysicalDevices( _instance, &gpu_count, gpu_list.data() );
_gpu = gpu_list[ 0 ];
vkGetPhysicalDeviceProperties( _gpu, &_gpu_properties );
}
{
uint32_t family_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties( _gpu, &family_count, nullptr );
std::vector<VkQueueFamilyProperties> family_property_list( family_count );
vkGetPhysicalDeviceQueueFamilyProperties( _gpu, &family_count, family_property_list.data() );
bool found = false;
for( uint32_t i=0; i < family_count; ++i ) {
if( family_property_list[ i ].queueFlags & VK_QUEUE_GRAPHICS_BIT ) {
found = true;
_graphics_family_index = i;
}
}
if( !found ) {
assert( 0 && "Vulkan ERROR: Queue family supporting graphics not found." );
std::exit( -1 );
}
}
float queue_priorities[] { 1.0f };
VkDeviceQueueCreateInfo device_queue_create_info {};
device_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
device_queue_create_info.queueFamilyIndex = _graphics_family_index;
device_queue_create_info.queueCount = 1;
device_queue_create_info.pQueuePriorities = queue_priorities;
VkDeviceCreateInfo device_create_info {};
device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
device_create_info.queueCreateInfoCount = 1;
device_create_info.pQueueCreateInfos = &device_queue_create_info;
device_create_info.enabledLayerCount = _device_layers.size();
device_create_info.ppEnabledLayerNames = _device_layers.data();
device_create_info.enabledExtensionCount = _device_extensions.size();
device_create_info.ppEnabledExtensionNames = _device_extensions.data();
ErrorCheck( vkCreateDevice( _gpu, &device_create_info, nullptr, &_device ) );
vkGetDeviceQueue( _device, _graphics_family_index, 0, &_queue );
}
VulkanContext::VulkanContext(VkInstance instance, VkPhysicalDevice physical_device)
: m_instance(instance), m_physical_device(physical_device)
{
// Read device physical memory properties, we need it for allocating buffers
vkGetPhysicalDeviceProperties(physical_device, &m_device_properties);
vkGetPhysicalDeviceMemoryProperties(physical_device, &m_device_memory_properties);
// Would any drivers be this silly? I hope not...
m_device_properties.limits.minUniformBufferOffsetAlignment = std::max(
m_device_properties.limits.minUniformBufferOffsetAlignment, static_cast<VkDeviceSize>(1));
m_device_properties.limits.minTexelBufferOffsetAlignment = std::max(
m_device_properties.limits.minTexelBufferOffsetAlignment, static_cast<VkDeviceSize>(1));
m_device_properties.limits.optimalBufferCopyOffsetAlignment = std::max(
m_device_properties.limits.optimalBufferCopyOffsetAlignment, static_cast<VkDeviceSize>(1));
m_device_properties.limits.optimalBufferCopyRowPitchAlignment = std::max(
m_device_properties.limits.optimalBufferCopyRowPitchAlignment, static_cast<VkDeviceSize>(1));
}
void EnumAndInitAllDeviceAdapter(rhi::IDeviceAdapter** & adapterList, uint32* count, bool debug)
{
*count = (uint32)RHIRoot::GetPhysicDevices().size();
adapterList = new rhi::IDeviceAdapter*[*count];
for (size_t i = 0; i < *count; i++)
{
auto& gpu = RHIRoot::GetPhysicDevices()[i];
VkPhysicalDeviceProperties properties = {};
vkGetPhysicalDeviceProperties(gpu, &properties);
auto da = new DeviceAdapter(&gpu);
adapterList[i] = da;
auto dev = da->GetDevice();
auto ret = dev->Create(da, debug);
K3D_ASSERT(ret == rhi::IDevice::DeviceFound);
VKLOG(Info, "DeviceName is %s, VendorId is %d.", properties.deviceName, properties.vendorID);
}
}
void Renderer::checkDeviceProperties(VkPhysicalDevice gpu) {
VkPhysicalDeviceProperties properties;
VkPhysicalDeviceFeatures features;
vkGetPhysicalDeviceProperties(gpu, &properties);
vkGetPhysicalDeviceFeatures(gpu, &features);
printf("%s\n", properties.deviceName);
printf("Vulkan Version: %d.%d.%d\n",
VK_VERSION_MAJOR(properties.apiVersion),
VK_VERSION_MINOR(properties.apiVersion),
VK_VERSION_PATCH(properties.apiVersion));
printf("Driver Version: %d.%d.%d\n\n",
VK_VERSION_MAJOR(properties.driverVersion),
VK_VERSION_MINOR(properties.driverVersion),
VK_VERSION_PATCH(properties.driverVersion));
}
void VideoBackend::InitBackendInfo()
{
VulkanContext::PopulateBackendInfo(&g_Config);
if (LoadVulkanLibrary())
{
VkInstance temp_instance = VulkanContext::CreateVulkanInstance(false, false, false);
if (temp_instance)
{
if (LoadVulkanInstanceFunctions(temp_instance))
{
VulkanContext::GPUList gpu_list = VulkanContext::EnumerateGPUs(temp_instance);
VulkanContext::PopulateBackendInfoAdapters(&g_Config, gpu_list);
if (!gpu_list.empty())
{
// Use the selected adapter, or the first to fill features.
size_t device_index = static_cast<size_t>(g_Config.iAdapter);
if (device_index >= gpu_list.size())
device_index = 0;
VkPhysicalDevice gpu = gpu_list[device_index];
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(gpu, &properties);
VkPhysicalDeviceFeatures features;
vkGetPhysicalDeviceFeatures(gpu, &features);
VulkanContext::PopulateBackendInfoFeatures(&g_Config, gpu, properties, features);
VulkanContext::PopulateBackendInfoMultisampleModes(&g_Config, gpu, properties);
}
}
vkDestroyInstance(temp_instance, nullptr);
}
else
{
PanicAlert("Failed to create Vulkan instance.");
}
UnloadVulkanLibrary();
}
else
{
PanicAlert("Failed to load Vulkan library.");
}
}
VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION)
{
width = 1280;
height = 720;
zoom = -30.0;
zoomSpeed = 2.5f;
rotationSpeed = 0.5f;
timerSpeed *= 0.5f;
rotation = { -32.5, 45.0, 0.0 };
title = "Vulkan Example - Push constants";
// Check requested push constant size against hardware limit
// Specs require 128 bytes, so if the device complies our
// push constant buffer should always fit into memory
VkPhysicalDeviceProperties deviceProps;
vkGetPhysicalDeviceProperties(physicalDevice, &deviceProps);
assert(sizeof(pushConstants) <= deviceProps.limits.maxPushConstantsSize);
}
bool VulkanContext::SelectDeviceFeatures()
{
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(m_physical_device, &properties);
VkPhysicalDeviceFeatures available_features;
vkGetPhysicalDeviceFeatures(m_physical_device, &available_features);
// Not having geometry shaders or wide lines will cause issues with rendering.
if (!available_features.geometryShader && !available_features.wideLines)
WARN_LOG(VIDEO, "Vulkan: Missing both geometryShader and wideLines features.");
if (!available_features.largePoints)
WARN_LOG(VIDEO, "Vulkan: Missing large points feature. CPU EFB writes will be slower.");
if (!available_features.occlusionQueryPrecise)
WARN_LOG(VIDEO, "Vulkan: Missing precise occlusion queries. Perf queries will be inaccurate.");
// Check push constant size.
if (properties.limits.maxPushConstantsSize < static_cast<u32>(PUSH_CONSTANT_BUFFER_SIZE))
{
PanicAlert("Vulkan: Push contant buffer size %u is below minimum %u.",
properties.limits.maxPushConstantsSize, static_cast<u32>(PUSH_CONSTANT_BUFFER_SIZE));
return false;
}
// Enable the features we use.
m_device_features.dualSrcBlend = available_features.dualSrcBlend;
m_device_features.geometryShader = available_features.geometryShader;
m_device_features.samplerAnisotropy = available_features.samplerAnisotropy;
m_device_features.logicOp = available_features.logicOp;
m_device_features.fragmentStoresAndAtomics = available_features.fragmentStoresAndAtomics;
m_device_features.sampleRateShading = available_features.sampleRateShading;
m_device_features.largePoints = available_features.largePoints;
m_device_features.shaderStorageImageMultisample =
available_features.shaderStorageImageMultisample;
m_device_features.shaderTessellationAndGeometryPointSize =
available_features.shaderTessellationAndGeometryPointSize;
m_device_features.occlusionQueryPrecise = available_features.occlusionQueryPrecise;
m_device_features.shaderClipDistance = available_features.shaderClipDistance;
m_device_features.depthClamp = available_features.depthClamp;
m_device_features.textureCompressionBC = available_features.textureCompressionBC;
return true;
}
void Renderer::_InitDevice()
{
uint32_t deviceCount = 0;
VkResult result = vkEnumeratePhysicalDevices(instance, &deviceCount, NULL);
if (result != VK_SUCCESS) {
fprintf(stderr, "Failed to query the number of physical devices present: %d\n", result);
abort();
}
// There has to be at least one device present
if (deviceCount == 0) {
fprintf(stderr, "Couldn't detect any device present with Vulkan support: %d\n", result);
abort();
}
// Get the physical devices
std::vector<VkPhysicalDevice> physicalDevices(deviceCount);
result = vkEnumeratePhysicalDevices(instance, &deviceCount, &physicalDevices[0]);
if (result != VK_SUCCESS) {
fprintf(stderr, "Faied to enumerate physical devices present: %d\n", result);
abort();
}
// Enumerate all physical devices
VkPhysicalDeviceProperties deviceProperties;
for (uint32_t i = 0; i < deviceCount; i++) {
memset(&deviceProperties, 0, sizeof deviceProperties);
vkGetPhysicalDeviceProperties(physicalDevices[i], &deviceProperties);
printf("Driver Version: %d\n", deviceProperties.driverVersion);
printf("Device Name: %s\n", deviceProperties.deviceName);
printf("Device Type: %d\n", deviceProperties.deviceType);
printf("API Version: %d.%d.%d\n",
// See note below regarding this:
(deviceProperties.apiVersion >> 22) & 0x3FF,
(deviceProperties.apiVersion >> 12) & 0x3FF,
(deviceProperties.apiVersion & 0xFFF));
}
}
static gboolean
_physical_device_info (GstVulkanDevice * device, GError ** error)
{
VkPhysicalDeviceProperties props;
VkPhysicalDevice gpu;
gpu = gst_vulkan_device_get_physical_device (device);
if (!gpu) {
g_set_error (error, GST_VULKAN_ERROR, VK_ERROR_INITIALIZATION_FAILED,
"Failed to retrieve physical device");
return FALSE;
}
vkGetPhysicalDeviceProperties (gpu, &props);
GST_INFO_OBJECT (device, "device name %s type %s api version %u, "
"driver version %u vendor ID 0x%x, device ID 0x%x", props.deviceName,
_device_type_to_string (props.deviceType), props.apiVersion,
props.driverVersion, props.vendorID, props.deviceID);
return TRUE;
}
bool Tutorial01::CheckPhysicalDeviceProperties( VkPhysicalDevice physical_device, uint32_t &queue_family_index ) {
VkPhysicalDeviceProperties device_properties;
VkPhysicalDeviceFeatures device_features;
vkGetPhysicalDeviceProperties( physical_device, &device_properties );
vkGetPhysicalDeviceFeatures( physical_device, &device_features );
uint32_t major_version = VK_VERSION_MAJOR( device_properties.apiVersion );
uint32_t minor_version = VK_VERSION_MINOR( device_properties.apiVersion );
uint32_t patch_version = VK_VERSION_PATCH( device_properties.apiVersion );
if( (major_version < 1) ||
(device_properties.limits.maxImageDimension2D < 4096) ) {
std::cout << "Physical device " << physical_device << " doesn't support required parameters!" << std::endl;
return false;
}
uint32_t queue_families_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, nullptr );
if( queue_families_count == 0 ) {
std::cout << "Physical device " << physical_device << " doesn't have any queue families!" << std::endl;
return false;
}
std::vector<VkQueueFamilyProperties> queue_family_properties( queue_families_count );
vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, queue_family_properties.data() );
for( uint32_t i = 0; i < queue_families_count; ++i ) {
if( (queue_family_properties[i].queueCount > 0) &&
(queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) ) {
queue_family_index = i;
std::cout << "Selected device: " << device_properties.deviceName << std::endl;
return true;
}
}
std::cout << "Could not find queue family with required properties on physical device " << physical_device << "!" << std::endl;
return false;
}
void RHIRoot::Initialize(const char * appName, bool debug)
{
vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dynlib::GetVulkanLib().ResolveEntry("vkCreateInstance"));
vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(dynlib::GetVulkanLib().ResolveEntry("vkDestroyInstance"));
vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(dynlib::GetVulkanLib().ResolveEntry("vkEnumeratePhysicalDevices"));
vkEnumerateInstanceLayerProperties = (PFN_vkEnumerateInstanceLayerProperties)dynlib::GetVulkanLib().ResolveEntry("vkEnumerateInstanceLayerProperties");
vkEnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)dynlib::GetVulkanLib().ResolveEntry("vkEnumerateInstanceExtensionProperties");
vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)dynlib::GetVulkanLib().ResolveEntry("vkGetPhysicalDeviceProperties");
vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)dynlib::GetVulkanLib().ResolveEntry("vkGetPhysicalDeviceMemoryProperties");
vkGetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties)dynlib::GetVulkanLib().ResolveEntry("vkGetPhysicalDeviceQueueFamilyProperties");
vkCreateDevice = (PFN_vkCreateDevice)dynlib::GetVulkanLib().ResolveEntry("vkCreateDevice");
EnumLayers();
VkResult err = CreateInstance(debug, appName);
if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
VKLOG(Error, "Cannot find a compatible Vulkan installable client driver: vkCreateInstance Failure");
}
else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
VKLOG(Error, "Cannot find a specified extension library: vkCreateInstance Failure");
}
else {
K3D_VK_VERIFY(err);
}
uint32_t gpuCount = 0;
K3D_VK_VERIFY(vkEnumeratePhysicalDevices(Instance, &gpuCount, nullptr));
VKLOG(Info, "RHIRoot::Initializer Device Count : %u .", gpuCount);
std::vector<VkPhysicalDevice> deviceList(gpuCount);
err = vkEnumeratePhysicalDevices(Instance, &gpuCount, deviceList.data());
VkPhysicalDeviceProperties physicalDeviceProperties = {};
vkGetPhysicalDeviceProperties(deviceList[0], &physicalDeviceProperties);
VKLOG(Info, "Vulkan First Device: %s", physicalDeviceProperties.deviceName);
PhysicalDevices.swap(deviceList);
}
VkResult Device::CreateDevice(VkPhysicalDevice gpu, bool withDebug, VkDevice * pDevice)
{
// get all device queues and find graphics queue
GetDeviceQueueProps(gpu);
// get device limits
vkGetPhysicalDeviceProperties(gpu, &m_PhysicalDeviceProperties);
std::array<float, 1> queuePriorities = { 0.0f };
VkDeviceQueueCreateInfo queueCreateInfo = {};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = m_GfxQueueIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = queuePriorities.data();
std::vector<const char*> enabledExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
VkDeviceCreateInfo deviceCreateInfo = {};
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.pNext = NULL;
deviceCreateInfo.queueCreateInfoCount = 1;
deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
deviceCreateInfo.pEnabledFeatures = NULL;
if (withDebug)
{
deviceCreateInfo.enabledLayerCount = (uint32)RHIRoot::s_LayerNames.size();
deviceCreateInfo.ppEnabledLayerNames = RHIRoot::s_LayerNames.data();
}
if (enabledExtensions.size() > 0)
{
deviceCreateInfo.enabledExtensionCount = (uint32_t)enabledExtensions.size();
deviceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
}
return vkCreateDevice(gpu, &deviceCreateInfo, nullptr, pDevice);
}
void VulkanExampleBase::initVulkan(bool enableValidation)
{
VkResult err;
// Vulkan instance
err = createInstance(enableValidation);
if (err)
{
vkTools::exitFatal("Could not create Vulkan instance : \n" + vkTools::errorString(err), "Fatal error");
}
#if defined(__ANDROID__)
loadVulkanFunctions(instance);
#endif
// Physical device
uint32_t gpuCount = 0;
// Get number of available physical devices
err = vkEnumeratePhysicalDevices(instance, &gpuCount, nullptr);
assert(!err);
assert(gpuCount > 0);
// Enumerate devices
std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
err = vkEnumeratePhysicalDevices(instance, &gpuCount, physicalDevices.data());
if (err)
{
vkTools::exitFatal("Could not enumerate phyiscal devices : \n" + vkTools::errorString(err), "Fatal error");
}
// Note :
// This example will always use the first physical device reported,
// change the vector index if you have multiple Vulkan devices installed
// and want to use another one
physicalDevice = physicalDevices[0];
// Find a queue that supports graphics operations
uint32_t graphicsQueueIndex = 0;
uint32_t queueCount;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, NULL);
assert(queueCount >= 1);
std::vector<VkQueueFamilyProperties> queueProps;
queueProps.resize(queueCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, queueProps.data());
for (graphicsQueueIndex = 0; graphicsQueueIndex < queueCount; graphicsQueueIndex++)
{
if (queueProps[graphicsQueueIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
break;
}
assert(graphicsQueueIndex < queueCount);
// Vulkan device
std::array<float, 1> queuePriorities = { 0.0f };
VkDeviceQueueCreateInfo queueCreateInfo = {};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = graphicsQueueIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = queuePriorities.data();
err = createDevice(queueCreateInfo, enableValidation);
assert(!err);
// Store properties (including limits) and features of the phyiscal device
// So examples can check against them and see if a feature is actually supported
vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);
#if defined(__ANDROID__)
LOGD(deviceProperties.deviceName);
#endif
// Gather physical device memory properties
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);
// Get the graphics queue
vkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
// Find a suitable depth format
VkBool32 validDepthFormat = vkTools::getSupportedDepthFormat(physicalDevice, &depthFormat);
assert(validDepthFormat);
swapChain.connect(instance, physicalDevice, device);
// Create synchronization objects
VkSemaphoreCreateInfo semaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
// Create a semaphore used to synchronize image presentation
// Ensures that the image is displayed before we start submitting new commands to the queu
err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.presentComplete);
assert(!err);
// Create a semaphore used to synchronize command submission
// Ensures that the image is not presented until all commands have been sumbitted and executed
err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.renderComplete);
assert(!err);
// Set up submit info structure
// Semaphores will stay the same during application lifetime
// Command buffer submission info is set by each example
submitInfo = vkTools::initializers::submitInfo();
submitInfo.pWaitDstStageMask = &submitPipelineStages;
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &semaphores.presentComplete;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &semaphores.renderComplete;
}
bool VulkanDevice::Init(VulkanInstance * vulkanInstance, HWND hwnd)
{
VkResult result;
// GPU
uint32_t numGPUs = 0;
vkEnumeratePhysicalDevices(vulkanInstance->GetInstance(), &numGPUs, VK_NULL_HANDLE);
if (numGPUs == 0)
{
gLogManager->AddMessage("ERROR: No GPUs found!");
return false;
}
std::vector<VkPhysicalDevice> pGPUs(numGPUs);
vkEnumeratePhysicalDevices(vulkanInstance->GetInstance(), &numGPUs, pGPUs.data());
gpu = pGPUs[0];
vkGetPhysicalDeviceProperties(gpu, &gpuProperties);
vkGetPhysicalDeviceMemoryProperties(gpu, &memoryProperties);
gLogManager->AddMessage("Rendering with: " + std::string(gpuProperties.deviceName));
// Queue family
uint32_t numQueueFamily = 0;
vkGetPhysicalDeviceQueueFamilyProperties(gpu, &numQueueFamily, VK_NULL_HANDLE);
if (numQueueFamily == 0)
{
gLogManager->AddMessage("ERROR: No Queue Families were found!");
return false;
}
queueFamiliyProperties.resize(numQueueFamily);
vkGetPhysicalDeviceQueueFamilyProperties(gpu, &numQueueFamily, queueFamiliyProperties.data());
// Surface
VkWin32SurfaceCreateInfoKHR win32SurfaceCI{};
win32SurfaceCI.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
win32SurfaceCI.hinstance = GetModuleHandle(NULL);
win32SurfaceCI.hwnd = hwnd;
result = vkCreateWin32SurfaceKHR(vulkanInstance->GetInstance(), &win32SurfaceCI, VK_NULL_HANDLE, &surface);
if (result != VK_SUCCESS)
{
gLogManager->AddMessage("ERROR: Couldn't create Win32 Surface!");
return false;
}
VkBool32 * supportsPresent = new VkBool32[queueFamiliyProperties.size()];
for (uint32_t i = 0; i < queueFamiliyProperties.size(); i++)
vkGetPhysicalDeviceSurfaceSupportKHR(gpu, i, surface, &supportsPresent[i]);
graphicsQueueFamilyIndex = UINT32_MAX;
for (uint32_t i = 0; i < queueFamiliyProperties.size(); i++)
{
if ((queueFamiliyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0)
{
if (supportsPresent[i] == VK_TRUE)
{
graphicsQueueFamilyIndex = i;
break;
}
}
}
delete[] supportsPresent;
if (graphicsQueueFamilyIndex == UINT32_MAX)
{
gLogManager->AddMessage("ERROR: Couldn't find a graphics queue family index!");
return false;
}
uint32_t numFormats;
result = vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, surface, &numFormats, VK_NULL_HANDLE);
if (result != VK_SUCCESS)
{
gLogManager->AddMessage("ERROR: Couldn't get surface formats!");
return false;
}
VkSurfaceFormatKHR * pSurfaceFormats = new VkSurfaceFormatKHR[numFormats];
result = vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, surface, &numFormats, pSurfaceFormats);
if (numFormats == 1 && pSurfaceFormats[0].format == VK_FORMAT_UNDEFINED)
format = VK_FORMAT_B8G8R8A8_UNORM;
else
format = pSurfaceFormats[0].format;
// Device queue
float pQueuePriorities[] = { 1.0f };
VkDeviceQueueCreateInfo deviceQueueCI{};
deviceQueueCI.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCI.queueCount = 1;
deviceQueueCI.queueFamilyIndex = graphicsQueueFamilyIndex;
deviceQueueCI.pQueuePriorities = pQueuePriorities;
VkPhysicalDeviceFeatures deviceFeatures{};
deviceFeatures.shaderClipDistance = VK_TRUE;
deviceFeatures.shaderCullDistance = VK_TRUE;
deviceFeatures.geometryShader = VK_TRUE;
deviceFeatures.shaderTessellationAndGeometryPointSize = VK_TRUE;
deviceFeatures.fillModeNonSolid = VK_TRUE;
// Device
VkDeviceCreateInfo deviceCI{};
deviceCI.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCI.queueCreateInfoCount = 1;
deviceCI.pQueueCreateInfos = &deviceQueueCI;
deviceCI.enabledExtensionCount = (uint32_t)deviceExtensions.size();
deviceCI.ppEnabledExtensionNames = deviceExtensions.data();
deviceCI.pEnabledFeatures = &deviceFeatures;
result = vkCreateDevice(gpu, &deviceCI, VK_NULL_HANDLE, &device);
if (result != VK_SUCCESS)
{
gLogManager->AddMessage("ERROR: vkCreateDevice() failed!");
return false;
}
vkGetDeviceQueue(device, graphicsQueueFamilyIndex, 0, &deviceQueue);
return true;
}
void VulkanContext::ChooseDevice(int physical_device) {
physical_device_ = physical_device;
ILOG("Chose physical device %d: %p", physical_device, physical_devices_[physical_device]);
GetDeviceLayerProperties();
if (!CheckLayers(device_layer_properties_, device_layer_names_)) {
WLOG("CheckLayers for device %d failed", physical_device);
}
vkGetPhysicalDeviceQueueFamilyProperties(physical_devices_[physical_device_], &queue_count, nullptr);
assert(queue_count >= 1);
queue_props.resize(queue_count);
vkGetPhysicalDeviceQueueFamilyProperties(physical_devices_[physical_device_], &queue_count, queue_props.data());
assert(queue_count >= 1);
// Detect preferred formats, in this order.
static const VkFormat depthStencilFormats[] = {
VK_FORMAT_D24_UNORM_S8_UINT,
VK_FORMAT_D32_SFLOAT_S8_UINT,
VK_FORMAT_D16_UNORM_S8_UINT,
};
deviceInfo_.preferredDepthStencilFormat = VK_FORMAT_UNDEFINED;
for (size_t i = 0; i < ARRAY_SIZE(depthStencilFormats); i++) {
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(physical_devices_[physical_device_], depthStencilFormats[i], &props);
if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) {
deviceInfo_.preferredDepthStencilFormat = depthStencilFormats[i];
break;
}
}
if (deviceInfo_.preferredDepthStencilFormat == VK_FORMAT_UNDEFINED) {
// WTF? This is bad.
ELOG("Could not find a usable depth stencil format.");
}
// This is as good a place as any to do this
vkGetPhysicalDeviceMemoryProperties(physical_devices_[physical_device_], &memory_properties);
vkGetPhysicalDeviceProperties(physical_devices_[physical_device_], &gpu_props);
// Optional features
vkGetPhysicalDeviceFeatures(physical_devices_[physical_device_], &featuresAvailable_);
memset(&featuresEnabled_, 0, sizeof(featuresEnabled_));
// Enable a few safe ones if they are available.
if (featuresAvailable_.dualSrcBlend) {
featuresEnabled_.dualSrcBlend = true;
}
if (featuresAvailable_.largePoints) {
featuresEnabled_.largePoints = true;
}
if (featuresAvailable_.wideLines) {
featuresEnabled_.wideLines = true;
}
if (featuresAvailable_.geometryShader) {
featuresEnabled_.geometryShader = true;
}
if (featuresAvailable_.logicOp) {
featuresEnabled_.logicOp = true;
}
if (featuresAvailable_.depthClamp) {
featuresEnabled_.depthClamp = true;
}
if (featuresAvailable_.depthBounds) {
featuresEnabled_.depthBounds = true;
}
if (featuresAvailable_.samplerAnisotropy) {
featuresEnabled_.samplerAnisotropy = true;
}
// For easy wireframe mode, someday.
if (featuresEnabled_.fillModeNonSolid) {
featuresEnabled_.fillModeNonSolid = true;
}
GetDeviceLayerExtensionList(nullptr, device_extension_properties_);
device_extensions_enabled_.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
}
VkCtx( VkPhysicalDevice physdev, VkDevice device, VkQueue queue, VkCommandBuffer cmdbuf )
: m_device( device )
, m_queue( queue )
, m_context( s_gpuCtxCounter.fetch_add( 1, std::memory_order_relaxed ) )
, m_head( 0 )
, m_tail( 0 )
, m_oldCnt( 0 )
{
assert( m_context != 255 );
VkPhysicalDeviceProperties prop;
vkGetPhysicalDeviceProperties( physdev, &prop );
const float period = prop.limits.timestampPeriod;
VkQueryPoolCreateInfo poolInfo = {};
poolInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
poolInfo.queryCount = QueryCount;
poolInfo.queryType = VK_QUERY_TYPE_TIMESTAMP;
vkCreateQueryPool( device, &poolInfo, nullptr, &m_query );
VkCommandBufferBeginInfo beginInfo = {};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
VkSubmitInfo submitInfo = {};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &cmdbuf;
vkBeginCommandBuffer( cmdbuf, &beginInfo );
vkCmdResetQueryPool( cmdbuf, m_query, 0, QueryCount );
vkEndCommandBuffer( cmdbuf );
vkQueueSubmit( queue, 1, &submitInfo, VK_NULL_HANDLE );
vkQueueWaitIdle( queue );
vkBeginCommandBuffer( cmdbuf, &beginInfo );
vkCmdWriteTimestamp( cmdbuf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, m_query, 0 );
vkEndCommandBuffer( cmdbuf );
vkQueueSubmit( queue, 1, &submitInfo, VK_NULL_HANDLE );
vkQueueWaitIdle( queue );
int64_t tcpu = Profiler::GetTime();
int64_t tgpu;
vkGetQueryPoolResults( device, m_query, 0, 1, sizeof( tgpu ), &tgpu, sizeof( tgpu ), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT );
vkBeginCommandBuffer( cmdbuf, &beginInfo );
vkCmdResetQueryPool( cmdbuf, m_query, 0, 1 );
vkEndCommandBuffer( cmdbuf );
vkQueueSubmit( queue, 1, &submitInfo, VK_NULL_HANDLE );
vkQueueWaitIdle( queue );
Magic magic;
auto& token = s_token.ptr;
auto& tail = token->get_tail_index();
auto item = token->enqueue_begin<tracy::moodycamel::CanAlloc>( magic );
MemWrite( &item->hdr.type, QueueType::GpuNewContext );
MemWrite( &item->gpuNewContext.cpuTime, tcpu );
MemWrite( &item->gpuNewContext.gpuTime, tgpu );
memset( &item->gpuNewContext.thread, 0, sizeof( item->gpuNewContext.thread ) );
MemWrite( &item->gpuNewContext.period, period );
MemWrite( &item->gpuNewContext.context, m_context );
MemWrite( &item->gpuNewContext.accuracyBits, uint8_t( 0 ) );
#ifdef TRACY_ON_DEMAND
s_profiler.DeferItem( *item );
#endif
tail.store( magic + 1, std::memory_order_release );
}
HRESULT STDMETHODCALLTYPE C9::GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9 *pCaps)
{
/*
https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html#VkPhysicalDeviceProperties
https://msdn.microsoft.com/en-us/library/windows/desktop/bb172513(v=vs.85).aspx
https://msdn.microsoft.com/en-us/library/windows/desktop/bb172635(v=vs.85).aspx
https://msdn.microsoft.com/en-us/library/windows/desktop/bb172591(v=vs.85).aspx
*/
//Fetch the properties & features from the physical device.
VkPhysicalDeviceProperties properties;
VkPhysicalDeviceFeatures features;
vkGetPhysicalDeviceProperties(this->mPhysicalDevices[Adapter], &properties);
vkGetPhysicalDeviceFeatures(this->mPhysicalDevices[Adapter], &features);
//Translate the vulkan properties & features into D3D9 capabilities.
pCaps->DeviceType = DeviceType;
pCaps->AdapterOrdinal=0;
pCaps->Caps=0;
pCaps->Caps2 = D3DCAPS2_CANMANAGERESOURCE | D3DCAPS2_DYNAMICTEXTURES | D3DCAPS2_FULLSCREENGAMMA | D3DCAPS2_CANAUTOGENMIPMAP;
pCaps->Caps3 = D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD | D3DCAPS3_COPY_TO_VIDMEM | D3DCAPS3_COPY_TO_SYSTEMMEM | D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION;
pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_DEFAULT | D3DPRESENT_INTERVAL_ONE | D3DPRESENT_INTERVAL_TWO | D3DPRESENT_INTERVAL_THREE | D3DPRESENT_INTERVAL_FOUR | D3DPRESENT_INTERVAL_IMMEDIATE;
pCaps->CursorCaps = D3DCURSORCAPS_COLOR | D3DCURSORCAPS_LOWRES;
pCaps->DevCaps = D3DDEVCAPS_CANBLTSYSTONONLOCAL | D3DDEVCAPS_CANRENDERAFTERFLIP | D3DDEVCAPS_DRAWPRIMITIVES2 | D3DDEVCAPS_DRAWPRIMITIVES2EX | D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY | D3DDEVCAPS_HWRASTERIZATION | D3DDEVCAPS_HWTRANSFORMANDLIGHT | D3DDEVCAPS_PUREDEVICE | D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_TEXTUREVIDEOMEMORY | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | D3DDEVCAPS_TLVERTEXVIDEOMEMORY;
pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_MASKZ | D3DPMISCCAPS_CULLNONE | D3DPMISCCAPS_CULLCW | D3DPMISCCAPS_CULLCCW | D3DPMISCCAPS_COLORWRITEENABLE | D3DPMISCCAPS_CLIPPLANESCALEDPOINTS | D3DPMISCCAPS_TSSARGTEMP | D3DPMISCCAPS_BLENDOP | D3DPMISCCAPS_INDEPENDENTWRITEMASKS | D3DPMISCCAPS_FOGANDSPECULARALPHA | D3DPMISCCAPS_SEPARATEALPHABLEND | D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS | D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING | D3DPMISCCAPS_FOGVERTEXCLAMPED;
pCaps->RasterCaps = D3DPRASTERCAPS_ANISOTROPY | D3DPRASTERCAPS_COLORPERSPECTIVE | D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_DEPTHBIAS | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_FOGTABLE | D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_MIPMAPLODBIAS | D3DPRASTERCAPS_MULTISAMPLE_TOGGLE | D3DPRASTERCAPS_SCISSORTEST | D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS | D3DPRASTERCAPS_WFOG | D3DPRASTERCAPS_ZFOG | D3DPRASTERCAPS_ZTEST;
pCaps->ZCmpCaps = D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL | D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS;
pCaps->SrcBlendCaps = D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR | D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA | D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR | D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA | D3DPBLENDCAPS_BOTHINVSRCALPHA | D3DPBLENDCAPS_BLENDFACTOR | D3DPBLENDCAPS_INVSRCCOLOR2 | D3DPBLENDCAPS_SRCCOLOR2;
pCaps->DestBlendCaps = pCaps->SrcBlendCaps;
pCaps->AlphaCmpCaps = D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL | D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS;
pCaps->ShadeCaps = D3DPSHADECAPS_COLORGOURAUDRGB | D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_ALPHAGOURAUDBLEND | D3DPSHADECAPS_FOGGOURAUD;
pCaps->TextureCaps = D3DPTEXTURECAPS_ALPHA | D3DPTEXTURECAPS_ALPHAPALETTE | D3DPTEXTURECAPS_PERSPECTIVE | D3DPTEXTURECAPS_PROJECTED | D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_VOLUMEMAP | D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_CUBEMAP_POW2 | D3DPTEXTURECAPS_VOLUMEMAP_POW2 | D3DPTEXTURECAPS_MIPMAP | D3DPTEXTURECAPS_MIPVOLUMEMAP | D3DPTEXTURECAPS_MIPCUBEMAP;
pCaps->TextureFilterCaps = D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MINFANISOTROPIC | D3DPTFILTERCAPS_MIPFPOINT | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | D3DPTFILTERCAPS_MAGFLINEAR | D3DPTFILTERCAPS_MAGFANISOTROPIC;
pCaps->CubeTextureFilterCaps = pCaps->TextureFilterCaps;
pCaps->VolumeTextureFilterCaps = pCaps->TextureFilterCaps;
pCaps->TextureAddressCaps = D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_INDEPENDENTUV | D3DPTADDRESSCAPS_WRAP | D3DPTADDRESSCAPS_MIRROR | D3DPTADDRESSCAPS_CLAMP | D3DPTADDRESSCAPS_MIRRORONCE;
pCaps->VolumeTextureAddressCaps = pCaps->TextureAddressCaps;
pCaps->LineCaps = D3DLINECAPS_ALPHACMP | D3DLINECAPS_BLEND | D3DLINECAPS_TEXTURE | D3DLINECAPS_ZTEST | D3DLINECAPS_FOG;
pCaps->MaxTextureWidth = properties.limits.maxImageDimension2D; //Revisit
pCaps->MaxTextureHeight = properties.limits.maxImageDimension2D; //Revisit
pCaps->MaxVolumeExtent= properties.limits.maxImageDimensionCube; //Revisit
pCaps->MaxTextureRepeat= 32768; //revisit
pCaps->MaxTextureAspectRatio = pCaps->MaxTextureWidth;
pCaps->MaxAnisotropy= features.samplerAnisotropy;
pCaps->MaxVertexW = 1e10f; //revisit
pCaps->GuardBandLeft = -1e9f; //revisit
pCaps->GuardBandTop = -1e9f; //revisit
pCaps->GuardBandRight = 1e9f; //revisit
pCaps->GuardBandBottom = 1e9f; //revisit
pCaps->ExtentsAdjust = 0.0f; //revisit
pCaps->StencilCaps = D3DSTENCILCAPS_KEEP | D3DSTENCILCAPS_ZERO | D3DSTENCILCAPS_REPLACE | D3DSTENCILCAPS_INCRSAT | D3DSTENCILCAPS_DECRSAT | D3DSTENCILCAPS_INVERT | D3DSTENCILCAPS_INCR | D3DSTENCILCAPS_DECR | D3DSTENCILCAPS_TWOSIDED;
pCaps->FVFCaps = D3DFVFCAPS_PSIZE;
pCaps->TextureOpCaps = D3DTEXOPCAPS_DISABLE | D3DTEXOPCAPS_SELECTARG1 | D3DTEXOPCAPS_SELECTARG2 | D3DTEXOPCAPS_MODULATE | D3DTEXOPCAPS_MODULATE2X | D3DTEXOPCAPS_MODULATE4X | D3DTEXOPCAPS_ADD | D3DTEXOPCAPS_ADDSIGNED | D3DTEXOPCAPS_ADDSIGNED2X | D3DTEXOPCAPS_SUBTRACT | D3DTEXOPCAPS_ADDSMOOTH | D3DTEXOPCAPS_BLENDDIFFUSEALPHA | D3DTEXOPCAPS_BLENDTEXTUREALPHA | D3DTEXOPCAPS_BLENDFACTORALPHA | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM | D3DTEXOPCAPS_BLENDCURRENTALPHA | D3DTEXOPCAPS_PREMODULATE | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA | D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP | D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3 | D3DTEXOPCAPS_MULTIPLYADD | D3DTEXOPCAPS_LERP;
pCaps->MaxTextureBlendStages = properties.limits.maxDescriptorSetSamplers; //revisit
pCaps->MaxSimultaneousTextures= properties.limits.maxDescriptorSetSampledImages; //revisit
pCaps->VertexProcessingCaps = D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER | D3DVTXPCAPS_TWEENING;
pCaps->MaxActiveLights=0; //Revsit should be infinite but games may not read it that way.
pCaps->MaxUserClipPlanes = 8; //revisit
pCaps->MaxVertexBlendMatrices = 4; //revisit
pCaps->MaxVertexBlendMatrixIndex = 7; //revisit
pCaps->MaxPointSize= properties.limits.pointSizeRange[1]; //revisit
pCaps->MaxPrimitiveCount = 0xFFFFFFFF; //revisit
pCaps->MaxVertexIndex = 0xFFFFFFFF; //revisit
pCaps->MaxStreams = properties.limits.maxVertexInputBindings; //revisit
pCaps->MaxStreamStride= properties.limits.maxVertexInputBindingStride; //revisit
pCaps->VertexShaderVersion= D3DVS_VERSION(3, 0);
pCaps->MaxVertexShaderConst=256; //revisit
pCaps->PixelShaderVersion = D3DPS_VERSION(3, 0);
pCaps->PixelShader1xMaxValue = 65504.f;
pCaps->DevCaps2 = D3DDEVCAPS2_STREAMOFFSET | D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET | D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES;
pCaps->MasterAdapterOrdinal=0;
pCaps->AdapterOrdinalInGroup=0;
pCaps->NumberOfAdaptersInGroup = 1;
pCaps->DeclTypes= D3DDTCAPS_UBYTE4 | D3DDTCAPS_UBYTE4N | D3DDTCAPS_SHORT2N | D3DDTCAPS_SHORT4N | D3DDTCAPS_USHORT2N | D3DDTCAPS_USHORT4N | D3DDTCAPS_UDEC3 | D3DDTCAPS_DEC3N | D3DDTCAPS_FLOAT16_2 | D3DDTCAPS_FLOAT16_4;
pCaps->NumSimultaneousRTs = 4; //revisit
pCaps->StretchRectFilterCaps= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | D3DPTFILTERCAPS_MAGFLINEAR;
pCaps->VS20Caps.Caps = D3DVS20CAPS_PREDICATION;
pCaps->VS20Caps.DynamicFlowControlDepth = 24; //revsit
pCaps->VS20Caps.StaticFlowControlDepth = 4; //revsit
pCaps->VS20Caps.NumTemps = 32; //revsit
pCaps->PS20Caps.Caps = D3DPS20CAPS_ARBITRARYSWIZZLE | D3DPS20CAPS_GRADIENTINSTRUCTIONS | D3DPS20CAPS_PREDICATION;
pCaps->PS20Caps.DynamicFlowControlDepth = 24; //revsit
pCaps->PS20Caps.StaticFlowControlDepth = 4; //revsit
pCaps->PS20Caps.NumTemps = 32; //revsit
pCaps->VertexTextureFilterCaps = pCaps->TextureFilterCaps; //revisit
pCaps->MaxVertexShader30InstructionSlots = 32768; //revisit
pCaps->MaxPixelShader30InstructionSlots = 32768; //revisit
pCaps->MaxVShaderInstructionsExecuted = 65535 < pCaps->MaxVertexShader30InstructionSlots * 32 ? pCaps->MaxVertexShader30InstructionSlots * 32: 65535; //revisit
pCaps->MaxPShaderInstructionsExecuted = 65535 < pCaps->MaxPixelShader30InstructionSlots * 32 ? pCaps->MaxPixelShader30InstructionSlots * 32 : 65535; //revisit
pCaps->MaxNpatchTessellationLevel = 0.0f;
pCaps->Reserved5 = 0;
return S_OK;
}
bool vulkan_check_physical_device(IWindow* window,
VkPhysicalDevice physical_device,
VkSurfaceKHR presentationSurface,
const std::vector<const char*>& extensions,
uint32_t& queue_family_index,
uint32_t& selected_present_queue_family_index)
{
Assert(window != nullptr);
vulkan_device_check_extensions(extensions, physical_device);
VkPhysicalDeviceProperties device_properties;
VkPhysicalDeviceFeatures device_features;
vkGetPhysicalDeviceProperties(physical_device, &device_properties);
vkGetPhysicalDeviceFeatures(physical_device, &device_features);
Assert(device_properties.apiVersion >= VK_MAKE_VERSION(1, 0, 0));
Assert(device_properties.limits.maxImageDimension2D >= 4096);
Assert(device_features.shaderClipDistance == VK_TRUE); // This is just checked, not enabled
uint32_t queue_families_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_families_count, nullptr);
Assert(queue_families_count > 0, "device doesn't have any queue families");
if (queue_families_count == 0)
return false;
std::vector<VkQueueFamilyProperties> queue_family_properties(queue_families_count);
std::vector<VkBool32> queue_present_support(queue_families_count);
vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_families_count, &queue_family_properties[0]);
uint32_t graphics_queue_family_index = UINT32_MAX;
uint32_t present_queue_family_index = UINT32_MAX;
for (uint32_t i = 0; i < queue_families_count; ++i)
{
Assert(vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, i, presentationSurface, &queue_present_support[i])
== VK_SUCCESS);
if ((queue_family_properties[i].queueCount > 0)
&& (queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT))
{
// Select first queue that supports graphics
if (graphics_queue_family_index == UINT32_MAX)
graphics_queue_family_index = i;
Assert(vulkan_queue_family_has_presentation_support(physical_device, i, window)
== (queue_present_support[i] == VK_TRUE),
"Queue family presentation support mismatch.");
// If there is queue that supports both graphics and present - prefer it
if (queue_present_support[i])
{
queue_family_index = i;
selected_present_queue_family_index = i;
return true;
}
}
}
// We don't have queue that supports both graphics and present so we have to use separate queues
for (uint32_t i = 0; i < queue_families_count; ++i)
{
if (queue_present_support[i] == VK_TRUE)
{
present_queue_family_index = i;
break;
}
}
Assert(graphics_queue_family_index != UINT32_MAX);
Assert(present_queue_family_index != UINT32_MAX);
queue_family_index = graphics_queue_family_index;
selected_present_queue_family_index = present_queue_family_index;
return true;
}
void vulkan_choose_physical_device(ReaperRoot& root, VulkanBackend& backend, PhysicalDeviceInfo& physicalDeviceInfo)
{
uint32_t deviceCount = 0;
Assert(vkEnumeratePhysicalDevices(backend.instance, &deviceCount, nullptr) == VK_SUCCESS);
Assert(deviceCount > 0);
log_debug(root, "vulkan: enumerating {} physical devices", deviceCount);
std::vector<VkPhysicalDevice> availableDevices(deviceCount);
Assert(vkEnumeratePhysicalDevices(backend.instance, &deviceCount, &availableDevices[0]) == VK_SUCCESS,
"error occurred during physical devices enumeration");
uint32_t selected_queue_family_index = UINT32_MAX;
uint32_t selected_present_queue_family_index = UINT32_MAX;
// Duplicated two times TODO merge
std::vector<const char*> extensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
VkPhysicalDevice chosenPhysicalDevice = VK_NULL_HANDLE;
for (auto& device : availableDevices)
{
if (vulkan_check_physical_device(root.renderer->window,
device,
backend.presentInfo.surface,
extensions,
selected_queue_family_index,
selected_present_queue_family_index))
{
chosenPhysicalDevice = device;
break;
}
}
Assert(chosenPhysicalDevice != VK_NULL_HANDLE, "could not select physical device based on the chosen properties");
physicalDeviceInfo.graphicsQueueIndex = selected_queue_family_index;
physicalDeviceInfo.presentQueueIndex = selected_present_queue_family_index;
vkGetPhysicalDeviceMemoryProperties(chosenPhysicalDevice, &physicalDeviceInfo.memory);
// re-fetch device infos TODO avoid
VkPhysicalDeviceProperties physicalDeviceProperties;
vkGetPhysicalDeviceProperties(chosenPhysicalDevice, &physicalDeviceProperties);
log_info(root, "vulkan: selecting device '{}'", physicalDeviceProperties.deviceName);
log_debug(root, "- type = {}", vulkan_physical_device_type_name(physicalDeviceProperties.deviceType));
uint32_t apiVersion = physicalDeviceProperties.apiVersion;
uint32_t driverVersion = physicalDeviceProperties.driverVersion;
log_debug(root,
"- api version = {}.{}.{}",
VK_VERSION_MAJOR(apiVersion),
VK_VERSION_MINOR(apiVersion),
VK_VERSION_PATCH(apiVersion));
log_debug(root,
"- driver version = {}.{}.{}",
VK_VERSION_MAJOR(driverVersion),
VK_VERSION_MINOR(driverVersion),
VK_VERSION_PATCH(driverVersion));
log_debug(root,
"- memory type count = {}, memory heap count = {}",
physicalDeviceInfo.memory.memoryTypeCount,
physicalDeviceInfo.memory.memoryHeapCount);
for (u32 i = 0; i < physicalDeviceInfo.memory.memoryHeapCount; ++i)
{
VkMemoryHeap& heap = physicalDeviceInfo.memory.memoryHeaps[i];
log_debug(root, "- heap {}: available size = {}, flags = {}", i, heap.size, heap.flags);
}
backend.physicalDevice = chosenPhysicalDevice;
}
int main(){
printf("This code initializes a Vulkan device");
/**
Steps required
1. Create Vulkan Instance
2. Enumerate the GPUs
3. Query Queues on the GPU (Queues represent on what 'channels' will the data process, query the queue
for COMPUTE type queue or GRAPHICS type queue
4. Create a queue priority
5. Create a device with information from 2, 3 and 4
**/
/** 1. Create Vulkan Instance **/
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pNext = NULL;
appInfo.pApplicationName = APP_SHORT_NAME;
appInfo.applicationVersion = 1;
appInfo.pEngineName = APP_SHORT_NAME;
appInfo.engineVersion = 1;
appInfo.apiVersion = VK_API_VERSION;
VkInstanceCreateInfo icInfo = {};
icInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
icInfo.pNext = NULL;
icInfo.flags = 0;
icInfo.pApplicationInfo = & appInfo;
icInfo.enabledExtensionCount = 0;
icInfo.ppEnabledExtensionNames = NULL;
icInfo.enabledLayerCount = 0;
icInfo.enabledLayerCount = NULL;
VkInstance instance;
VkResult res;
res = vkCreateInstance(&icInfo, NULL, &instance);
if(res == VK_ERROR_INCOMPATIBLE_DRIVER){
printf("Cannot find a Vulkan Compatible ICD\n");
exit(-1);
} else if(res){
printf("Some error occured\n");
exit(-1);
}
printf("Yay! Vulkan is initialized\n");
/** 2. Enumerate the GPUs **/
uint32_t gpuCount = 0;
res = vkEnumeratePhysicalDevices(instance, &gpuCount, NULL);
printf("found %d gpus\n", gpuCount);
VkPhysicalDevice* gpus = new VkPhysicalDevice[gpuCount];
printf("Listing gpus...\n", gpuCount);
res = vkEnumeratePhysicalDevices(instance, &gpuCount, gpus);
while(++idx < gpuCount){
VkPhysicalDeviceProperties props= {};
vkGetPhysicalDeviceProperties(gpus[idx], &props);
printf("%d-%d-%d-%d-%s\n", props.apiVersion, props.driverVersion, props.vendorID, props.deviceID, props.deviceName);
}
/** 3. Query for the supported queues **/
/** From renderdocs vulkan
Command buffers are submitted to a VkQueue.
The notion of queues are how work becomes serialised to be passed to the GPU.
A VkPhysicalDevice (remember way back? The GPU handle) can report a number of queue families with different capabilities.
e.g. a graphics queue family and a compute-only queue family.
When you create your device you ask for a certain number of queues from each family, and then you can enumerate them
from the device after creation with vkGetDeviceQueue().
**/
uint32_t queue_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties(gpus[0], &queue_count, NULL);
if(queue_count <= 0){
printf("No Queues found.. aborting\n");
exit(-1);
}
VkQueueFamilyProperties* queue_props = new VkQueueFamilyProperties[queue_count];
vkGetPhysicalDeviceQueueFamilyProperties(gpus[0], &queue_count, queue_props);
float queue_priorities[1] = {0.0}; /** 4. Create a queue priority **/
VkDeviceQueueCreateInfo qi = {};
qi.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
qi.pNext = NULL;
qi.queueCount = 1;
qi.pQueuePriorities = queue_priorities;
idx = -1;
while(++idx < queue_count){
if(queue_props[idx].queueFlags & VK_QUEUE_GRAPHICS_BIT){ //Look for a queue that has Graphics capabilities
qi.queueFamilyIndex = idx;
break;
}
}
/** 5. Create a device with information from 2, 3 and 4 **/
VkDeviceCreateInfo dci = {};
dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
dci.pNext = NULL;
dci.queueCreateInfoCount = 1;
dci.pQueueCreateInfos = &qi;
dci.enabledExtensionCount = 0;
dci.ppEnabledExtensionNames = NULL;
dci.enabledLayerCount = 0;
dci.ppEnabledLayerNames = NULL;
dci.pEnabledFeatures = NULL;
VkDevice device;
res = vkCreateDevice(gpus[0], &dci, NULL, &device);
if(res){
printf("There was a problem creating the device");
exit(-1);
}
/** All's great, first thing lets create a command buffer **/
VkCommandPoolCreateInfo cpci = {};
cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
cpci.pNext = NULL;
cpci.queueFamilyIndex = qi.queueFamilyIndex;
cpci.flags = 0;
VkCommandPool cp;
res = vkCreateCommandPool(device, &cpci, NULL, &cp);
if(res){
printf("There was a problem creating a command pool");
exit(-1);
}
/** Create a command buffer from the command pool **/
VkCommandBufferAllocateInfo cbai = {};
cbai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cbai.pNext = NULL;
cbai.commandPool = cp;
cbai.commandBufferCount = 1;
cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
VkCommandBuffer* commandBuffer = new VkCommandBuffer[1]; //single command
res = vkAllocateCommandBuffers(device, &cbai, commandBuffer);
if(res){
printf("There was a problem creating a command buffer");
exit(-1);
}
/** no, we never leave the crap behind **/
vkFreeCommandBuffers(device, cp, 1, commandBuffer);
vkDestroyCommandPool(device, cp, NULL);
vkDestroyDevice(device, NULL);
printf("Device created");
vkDestroyInstance(instance, NULL);
delete[] gpus;
return 0;
}
// Devices
void Renderer::_InitDevice() {
{
uint32_t gpu_count = 0;
// Read number of GPU's
vkEnumeratePhysicalDevices(_instance, &gpu_count, nullptr);
std::vector<VkPhysicalDevice> gpu_list(gpu_count);
// Populate list
vkEnumeratePhysicalDevices(_instance, &gpu_count, gpu_list.data());
_gpu = gpu_list[0]; // Get the first available list
vkGetPhysicalDeviceProperties(_gpu, &_gpu_properties);
vkGetPhysicalDeviceMemoryProperties(_gpu, &_gpu_memory_properties);
}
{
uint32_t family_count = 0;
// Read number of GPU queue family properties
vkGetPhysicalDeviceQueueFamilyProperties(_gpu, &family_count, nullptr);
std::vector<VkQueueFamilyProperties> family_property_list(family_count);
// Populate list
vkGetPhysicalDeviceQueueFamilyProperties(_gpu, &family_count, family_property_list.data());
// Find the graphics family
bool found = false;
for (uint32_t i = 0; i < family_count; ++i) {
if (family_property_list[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
found = true;
_graphics_family_index = i;
}
}
if (!found) {
assert(0 && "Vulkan ERROR: Queue family supporting graphics not found.");
std::exit(-1);
}
}
// Instance Layers
{
uint32_t layer_count = 0;
// Read the number of layers
vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
std::vector<VkLayerProperties> layer_property_list(layer_count);
// Populate list
vkEnumerateInstanceLayerProperties(&layer_count, layer_property_list.data());
#if BUILD_ENABLE_VULKAN_RUNTIME_DEBUG
std::cout << "Instance layers: \n";
for (auto &i : layer_property_list) {
std::cout << " " << i.layerName << "\t\t | " << i.description << std::endl;
}
std::cout << std::endl;
#endif
}
// Instance Extensions
{
uint32_t extension_count = 0;
// Read the number of extensions
vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr);
std::vector<VkExtensionProperties> extension_property_list(extension_count);
// Populate list
vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_property_list.data());
#if BUILD_ENABLE_VULKAN_RUNTIME_DEBUG
std::cout << "Instance extensions: \n";
for (auto &i : extension_property_list) {
std::cout << " " << i.extensionName << "\t\t | " << i.specVersion << std::endl;
}
std::cout << std::endl;
#endif
}
// Device Layers
{
uint32_t layer_count = 0;
// Read the number of layers
vkEnumerateDeviceLayerProperties(_gpu, &layer_count, nullptr);
std::vector<VkLayerProperties> layer_property_list(layer_count);
// Populate list
vkEnumerateDeviceLayerProperties(_gpu, &layer_count, layer_property_list.data());
#if BUILD_ENABLE_VULKAN_RUNTIME_DEBUG
std::cout << "Device layers: \n";
for (auto &i : layer_property_list) {
std::cout << " " << i.layerName << "\t\t | " << i.description << std::endl;
}
std::cout << std::endl;
#endif
}
// Device Extensions
{
uint32_t extension_count = 0;
// Read the number of extensions
vkEnumerateDeviceExtensionProperties(_gpu, nullptr, &extension_count, nullptr);
std::vector<VkExtensionProperties> extension_property_list(extension_count);
// Populate list
vkEnumerateDeviceExtensionProperties(_gpu, nullptr, &extension_count, extension_property_list.data());
#if BUILD_ENABLE_VULKAN_RUNTIME_DEBUG
std::cout << "Device extensions: \n";
for (auto &i : extension_property_list) {
std::cout << " " << i.extensionName << "\t\t | " << i.specVersion << std::endl;
}
std::cout << std::endl;
#endif
}
float queue_priorities[] {1.0f};
VkDeviceQueueCreateInfo device_queue_create_info {};
device_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
device_queue_create_info.queueFamilyIndex = _graphics_family_index;
device_queue_create_info.queueCount = 1;
device_queue_create_info.pQueuePriorities = queue_priorities;
VkDeviceCreateInfo device_create_info = {};
device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
device_create_info.queueCreateInfoCount = 1;
device_create_info.pQueueCreateInfos = &device_queue_create_info;
device_create_info.enabledLayerCount = (uint32_t) _device_layer_list.size();
device_create_info.ppEnabledLayerNames = _device_layer_list.data();
device_create_info.enabledExtensionCount = (uint32_t) _device_extension_list.size();
device_create_info.ppEnabledExtensionNames = _device_extension_list.data();
ErrorCheck(vkCreateDevice(_gpu, &device_create_info, nullptr, &_device));
vkGetDeviceQueue(_device, _graphics_family_index, 0, &_queue);
}
int main(int argc, char** argv) {
g_validationLayers = std::vector<const char*> {
"VK_LAYER_LUNARG_mem_tracker",
"VK_LAYER_GOOGLE_unique_objects",
};
// Init GLFW
{
// Handle GLFW errors
glfwSetErrorCallback([](int error, const char* description) {
std::cout << "GLFW error: " << error << " - " << description << std::endl;
});
// Initialize GLFW
if (!glfwInit())
error("Cannot initialize GLFW.");
// Check Vulkan support
if (!glfwVulkanSupported())
error("Cannot find compatible Vulkan client driver.");
}
// Get Validation layers
{
uint32_t numInstanceLayers = 0;
// Get numInstanceLayers
if (vkEnumerateInstanceLayerProperties(&numInstanceLayers, nullptr))
error("Vulkan: Could not enumerate instance layer properties.");
if (numInstanceLayers > 0) {
std::vector<VkLayerProperties> instanceLayers(numInstanceLayers);
if (vkEnumerateInstanceLayerProperties(&numInstanceLayers, instanceLayers.data()))
error("Vulkan: Could not enumerate instance layer properties.");
// Print layers:
std::cout << "Validation layers: " << std::endl;
for (int i = 0; i < numInstanceLayers; ++i) {
std::cout << "\t" << instanceLayers[i].layerName << std::endl;
std::cout << "\t\t" << instanceLayers[i].description << std::endl;
std::cout << std::endl;
}
std::cout << std::endl;
}
else
std::cout << "No validation layers found!" << std::endl;
// TODO: Check Layers
}
// Check instance extensions
{
int numRequiredExtensions;
const char** requiredExtensions;
// Get required extensions from GLFW
{
requiredExtensions = glfwGetRequiredInstanceExtensions((int*)&numRequiredExtensions);
if (numRequiredExtensions > 0) {
// Write to global g_extensions
for (int i = 0; i < numRequiredExtensions; ++i)
g_extensions.push_back(requiredExtensions[i]);
// Print
std::cout << "Required Instance Extensions(GLFW):" << std::endl;
for (int i = 0; i < numRequiredExtensions; ++i) {
std::cout << "\t" << requiredExtensions[i] << std::endl;
}
std::cout << std::endl;
}
// TODO: Check extensions
}
// Get Instance extensions
{
VkResult err;
uint32_t numInstanceExtensions;
err = vkEnumerateInstanceExtensionProperties(nullptr, &numInstanceExtensions, nullptr);
if (numInstanceExtensions > 0) {
std::vector<VkExtensionProperties> instanceExtensions(numInstanceExtensions);
err = vkEnumerateInstanceExtensionProperties(NULL, &numInstanceExtensions, instanceExtensions.data());
// Print
std::cout << "Instance Extensions: " << std::endl;
for (int i = 0; i < numInstanceExtensions; ++i) {
std::cout << "\t" <<instanceExtensions[i].extensionName << std::endl;
std::cout << "\t\t" << instanceExtensions[i].specVersion << std::endl;
std::cout << std::endl;
}
std::cout << std::endl;
}
// TODO: Check instance extensions(with required instance extensions)
}
}
// Create Vulkan Instance
{
VkApplicationInfo app;
{
app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app.pNext = nullptr;
app.pApplicationName = "Vulkan test 1";
app.applicationVersion = 0;
app.pEngineName = "Vulkan test 1";
app.engineVersion = 0;
app.apiVersion = VK_API_VERSION;
}
VkInstanceCreateInfo instanceInfo;
{
instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceInfo.pNext = nullptr;
instanceInfo.pApplicationInfo = &app;
instanceInfo.enabledLayerCount = g_validationLayers.size();
instanceInfo.ppEnabledLayerNames = g_validationLayers.data();
instanceInfo.enabledExtensionCount = g_extensions.size();
instanceInfo.ppEnabledExtensionNames = g_extensions.data();
}
// TODO: Aligned allocators
VkAllocationCallbacks allocator;
{
allocator.pUserData = nullptr;
allocator.pfnAllocation = [](void* pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope)->void* {
return malloc(size);
};
allocator.pfnFree = [](void* pUserData, void* pMemory) {
free(pMemory);
};
allocator.pfnReallocation = [](void* pUserData, void *pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope) {
free(pOriginal);
return malloc(size);
};
allocator.pfnInternalAllocation = nullptr;
allocator.pfnInternalFree = nullptr;
allocator.pfnReallocation = nullptr;
}
// Create vulkan instance
VkResult vkError = vkCreateInstance(&instanceInfo, &allocator, &g_vkInstance);
// Handle errors
switch (vkError) {
case VK_ERROR_INCOMPATIBLE_DRIVER:
error("Drivers do not support vulkan. Drivers could be outdated.");
break;
case VK_ERROR_EXTENSION_NOT_PRESENT:
error("Cannot find specified extension.");
break;
case VK_SUCCESS:
// Succes! (prevent default from catching success as error)
std::cout << "Vulkan instance created!" << std::endl;
break;
default:
error("Could not create vulkan Instance. Drivers could be outdated.");
break;
}
}
// Look for GPU device
{
uint32_t numGPUs;
VkResult vkError = vkEnumeratePhysicalDevices(g_vkInstance, &numGPUs, nullptr);
if (numGPUs < 0)
error("vkEnumeratePhysicalDevices could not find any GPU devices.");
if (vkError)
error("vkEnumeratePhysicalDevices could not enumerate GPU devices.");
if (numGPUs > 0) {
std::vector<VkPhysicalDevice> physicalDevices(numGPUs);
if (vkEnumeratePhysicalDevices(g_vkInstance, &numGPUs, physicalDevices.data()))
error("vkEnumeratePhysicalDevices could not enumerate GPU devices.");
g_vkGPU = physicalDevices[0];
std::cout << numGPUs << " GPUs found!" << std::endl;
}
}
// Get queue properties
{
uint32_t numQueues;
vkGetPhysicalDeviceProperties(g_vkGPU, &g_vkGPUProperties);
vkGetPhysicalDeviceQueueFamilyProperties(g_vkGPU, &numQueues, nullptr);
if (numQueues == 0)
error("vkGetPhysicalDeviceQueueFamilyProperties could not find any queues.");
g_vkQueueProperties = std::vector<VkQueueFamilyProperties>(numQueues);
vkGetPhysicalDeviceQueueFamilyProperties(g_vkGPU, &numQueues, g_vkQueueProperties.data());
}
// Look for device layers (Unecessary code that does nothing)
{
uint32_t numDeviceLayers;
if (vkEnumerateDeviceLayerProperties(g_vkGPU, &numDeviceLayers, nullptr))
error("vkEnumerateDeviceLayerProperties failed!");
if (numDeviceLayers > 0) {
std::vector<VkLayerProperties> deviceLayers(numDeviceLayers);
if (vkEnumerateDeviceLayerProperties(g_vkGPU, &numDeviceLayers, deviceLayers.data()))
error("vkEnumerateDeviceLayerProperties failed!");
// TODO: Check device layers.
}
}
// Look for device extensions (swapchain extension)
{
uint32_t numDeviceExtensions;
bool extensionSwapChainFound = false;
if (vkEnumerateDeviceExtensionProperties(g_vkGPU, nullptr, &numDeviceExtensions, nullptr))
error("vkEnumerateDeviceExtensionProperties failed!");
if (numDeviceExtensions > 0) {
std::vector<VkExtensionProperties> deviceExtensions(numDeviceExtensions);
if (vkEnumerateDeviceExtensionProperties(g_vkGPU, nullptr, &numDeviceExtensions, deviceExtensions.data()))
error("vkEnumerateDeviceExtensionProperties failed!");
// Search for swapchain extension
for (VkExtensionProperties extension : deviceExtensions) {
if (!strcmp(extension.extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME))
extensionSwapChainFound = true;
}
// Print
std::cout << std::endl << "Extensions:" << std::endl;
for (VkExtensionProperties extension : deviceExtensions) {
std::cout << extension.extensionName << "(" << extension.specVersion << ")" << std::endl;
}
std::cout << std::endl;
}
if (!extensionSwapChainFound)
error("Failed to find the " VK_KHR_SWAPCHAIN_EXTENSION_NAME " extension!");
}
// TODO: Validate
// Get instance function adresses
{
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceCapabilitiesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceFormatsKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfacePresentModesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetPhysicalDeviceSurfaceSupportKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, CreateSwapchainKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, DestroySwapchainKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, GetSwapchainImagesKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, AcquireNextImageKHR);
GET_INSTANCE_PROC_ADDR(g_vkInstance, QueuePresentKHR);
}
// Create window
{
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
g_window = glfwCreateWindow(g_width, g_height, "Vulkan test", NULL, NULL);
if (!g_window)
error("Could not create window!");
glfwSetWindowRefreshCallback(g_window, [](GLFWwindow* window) {
// TODO: draw();
});
glfwSetFramebufferSizeCallback(g_window, [](GLFWwindow* window, int width, int height) {
g_width = width;
g_height = height;
// TODO: resize();
});
}
// Init swapchain
{
glfwCreateWindowSurface(g_vkInstance, g_window, nullptr, &g_vkSurface);
std::vector<VkBool32> supportsPresent(g_vkQueueProperties.size());
for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i)
g_vkFPGetPhysicalDeviceSurfaceSupportKHR(g_vkGPU, i, g_vkSurface, &supportsPresent[i]);
uint32_t graphicsQueueNodeIndex = UINT32_MAX;
uint32_t presentQueueNodeIndex = UINT32_MAX;
for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i) {
if (graphicsQueueNodeIndex == UINT32_MAX) {
graphicsQueueNodeIndex = i;
}
if (supportsPresent[i] == VK_TRUE) {
graphicsQueueNodeIndex = i;
presentQueueNodeIndex = i;
break;
}
}
//if (presentQueueNodeIndex == UINT32_MAX) {
// for (uint32_t i = 0; i < g_vkQueueProperties.size(); ++i) {
// if (supportsPresent[i] == VK_TRUE) {
// presentQueueNodeIndex = i;
// }
// }
//}
if (graphicsQueueNodeIndex == UINT32_MAX || presentQueueNodeIndex == UINT32_MAX)
error("Could not find a graphics and a present queue.");
if (graphicsQueueNodeIndex != presentQueueNodeIndex)
error("Could not find a common graphics and present queue.");
g_vkGraphicsQueueNodeIndex = graphicsQueueNodeIndex;
//TODO: init device
{
float queuePriotities = 0.f;
VkDeviceQueueCreateInfo queue;
{
queue.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue.pNext = NULL;
queue.queueFamilyIndex = g_vkGraphicsQueueNodeIndex;
queue.queueCount = 1;
queue.pQueuePriorities = &queuePriotities;
}
}
//vkGetDeviceQueue(g_vkDevice, g_vkGraphicsQueueNodeIndex, 0, g_vkQueue);
}
std::cin.get();
return 0;
}
bool check_physical_device_properties(VkPhysicalDevice physical_device,
uint32_t &selected_graphics_queue_family_index,
uint32_t &selected_present_queue_family_index,
const std::vector<const char *> &device_extensions) {
uint32_t extensions_count = 0;
if ((vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &extensions_count, nullptr)
!= VK_SUCCESS)
|| (extensions_count == 0)) {
SET_ERROR (LOG_TYPE, "Error occurred during physical device %d extensions enumeration!", physical_device);
return false;
}
std::vector<VkExtensionProperties> available_extensions(extensions_count);
if (vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &extensions_count,
&available_extensions[0]) != VK_SUCCESS) {
SET_ERROR (LOG_TYPE, "Error occurred during physical device %d extensions enumeration!", physical_device);
return false;
}
for (size_t i = 0; i < device_extensions.size(); ++i) {
if (!utils::check_extension(device_extensions[i], available_extensions)) {
SET_ERROR (LOG_TYPE, "Physical device %d doesn't support extension named \"%s\"!", physical_device,
device_extensions[i]);
return false;
}
}
VkPhysicalDeviceProperties device_properties;
VkPhysicalDeviceFeatures device_features;
vkGetPhysicalDeviceProperties(physical_device, &device_properties);
vkGetPhysicalDeviceFeatures(physical_device, &device_features);
uint32_t major_version = VK_VERSION_MAJOR(device_properties.apiVersion);
if ((major_version < 1) && (device_properties.limits.maxImageDimension2D < 4096)) {
SET_ERROR (LOG_TYPE, "Physical device %d doesn't support required parameters!", physical_device);
return false;
}
uint32_t queue_families_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_families_count, nullptr);
if (queue_families_count == 0) {
SET_ERROR (LOG_TYPE, "Physical device %d doesn't have any handle families!", physical_device);
return false;
}
std::vector<VkQueueFamilyProperties> queue_family_properties(queue_families_count);
std::vector<VkBool32> queue_present_support(queue_families_count);
vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_families_count, &queue_family_properties[0]);
uint32_t graphics_queue_family_index = UINT32_MAX;
uint32_t present_queue_family_index = UINT32_MAX;
for (uint32_t i = 0; i < queue_families_count; ++i) {
vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, i, vk_globals::surface, &queue_present_support[i]);
if ((queue_family_properties[i].queueCount > 0)
&& (queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)) {
// Select first handle that supports graphics
if (graphics_queue_family_index == UINT32_MAX) {
graphics_queue_family_index = i;
}
// If there is handle that supports both graphics and present - prefer it
if (queue_present_support[i]) {
selected_graphics_queue_family_index = i;
selected_present_queue_family_index = i;
return true;
}
}
}
// We don't have handle that supports both graphics and present so we have to use separate queues
for (uint32_t i = 0; i < queue_families_count; ++i) {
if (queue_present_support[i]) {
present_queue_family_index = i;
break;
}
}
// If this device doesn't support queues with graphics and present capabilities don't use it
if ((graphics_queue_family_index == UINT32_MAX) || (present_queue_family_index == UINT32_MAX)) {
SET_ERROR (LOG_TYPE, "Could not find handle families with required properties on physical device %d!",
physical_device);
return false;
}
selected_graphics_queue_family_index = graphics_queue_family_index;
selected_present_queue_family_index = present_queue_family_index;
return true;
}
VkResult init_Vulkan(VkInstance& vk_instance, VkDevice* out_device, DrawCommandBuffer* out_draw_command_buffer, SwapChain* out_swap_chain)
{
if ((out_device == nullptr) || (out_swap_chain == nullptr))
{
return VK_ERROR_INITIALIZATION_FAILED;
}
VkApplicationInfo app_info = {};
app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app_info.pNext = nullptr;
app_info.pApplicationName = "VT Test";
app_info.applicationVersion = 0x00000001;
app_info.pEngineName = "Noengine";
app_info.engineVersion = 0x00;
app_info.apiVersion = VK_MAKE_VERSION(1, 0, 2);
std::vector<const char *> enabledExtensions = { VK_KHR_SURFACE_EXTENSION_NAME };
enabledExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
VkInstanceCreateInfo instance_info = {};
instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_info.pNext = nullptr;
instance_info.flags = 0;
instance_info.pApplicationInfo = &app_info;
instance_info.enabledLayerCount = 0;
instance_info.ppEnabledLayerNames = nullptr;
instance_info.enabledExtensionCount = static_cast<uint32_t>(enabledExtensions.size());
instance_info.ppEnabledExtensionNames = enabledExtensions.data();
VK_THROW(vkCreateInstance(&instance_info, nullptr, &vk_instance)); // Create Vulkan library instance
out_swap_chain->instance = GetModuleHandle(NULL);
out_swap_chain->window = setup_window(out_swap_chain->instance, 800, 600, "vk_test");
uint32_t gpu_count = 0;
// Get number of available physical devices
VK_THROW(vkEnumeratePhysicalDevices(vk_instance, &gpu_count, nullptr));
assert(gpu_count > 0);
std::vector<VkPhysicalDevice> physicalDevices(gpu_count); // Enumerate devices
VK_THROW(vkEnumeratePhysicalDevices(vk_instance, &gpu_count, physicalDevices.data()));
bool surface_created = false;
VkPhysicalDeviceProperties gpu_properties;
VkPhysicalDeviceFeatures gpu_feature;
for (uint32_t gidx = 0; gidx < gpu_count; ++gidx)
{
VkPhysicalDevice gpu = physicalDevices[gidx];
vkGetPhysicalDeviceProperties(gpu, &gpu_properties);
std::cout << gidx << "Driver Version: " << gpu_properties.driverVersion << "\n";
std::cout << gidx << "Device Name: " << gpu_properties.deviceName << "\n";
std::cout << gidx << "Device Type: " << gpu_properties.deviceType << "\n";
std::cout << gidx << "API Version: " << VK_VERSION_MAJOR(gpu_properties.apiVersion) << "." << VK_VERSION_MINOR(gpu_properties.apiVersion) << "." << VK_VERSION_PATCH(gpu_properties.apiVersion) << "\n";
// we can choose a gpu based on the features here.
vkGetPhysicalDeviceFeatures(gpu, &gpu_feature);
VkResult err = create_surface(vk_instance, gpu, out_device, out_draw_command_buffer, out_swap_chain);
if (err == VK_SUCCESS)
{
surface_created = true;
break;
}
}
if (!surface_created)
{
return VK_ERROR_INITIALIZATION_FAILED;
}
return VK_SUCCESS;
}