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