virtual void SetUp() {
VkResult err;
this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
this->app_info.pNext = NULL;
this->app_info.pApplicationName = "base";
this->app_info.applicationVersion = 1;
this->app_info.pEngineName = "unittest";
this->app_info.engineVersion = 1;
this->app_info.apiVersion = VK_API_VERSION_1_0;
VkInstanceCreateInfo inst_info = {};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pApplicationInfo = &app_info;
inst_info.enabledLayerCount = 0;
inst_info.ppEnabledLayerNames = NULL;
inst_info.enabledExtensionCount = 0;
inst_info.ppEnabledExtensionNames = NULL;
err = vkCreateInstance(&inst_info, NULL, &this->inst);
ASSERT_VK_SUCCESS(err);
err = vkEnumeratePhysicalDevices(this->inst, &this->gpu_count, NULL);
ASSERT_VK_SUCCESS(err);
ASSERT_LE(this->gpu_count, ARRAY_SIZE(objs)) << "Too many GPUs";
err = vkEnumeratePhysicalDevices(this->inst, &this->gpu_count, objs);
ASSERT_VK_SUCCESS(err);
ASSERT_GE(this->gpu_count, (uint32_t) 1) << "No GPU available";
this->m_device = new vk_testing::Device(objs[0]);
this->m_device->init();
}
vk_instance(const char *app_name,
unsigned app_version,
const lib::vector<const char*> &instance_extensions,
const lib::vector<const char*> &instance_layers)
: instance_extensions(instance_extensions), instance_layers(instance_layers)
{
VkApplicationInfo vk_app_info = {};
vk_app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
vk_app_info.pNext = nullptr;
vk_app_info.pApplicationName = app_name;
vk_app_info.applicationVersion = app_version;
vk_app_info.pEngineName = ste_name;
vk_app_info.engineVersion = (ste_version_major << 16) + ste_version_minor;
vk_app_info.apiVersion = vk_api_version;
VkInstanceCreateInfo inst_info = {};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = nullptr;
inst_info.flags = 0;
inst_info.enabledExtensionCount = static_cast<std::uint32_t>(instance_extensions.size());
inst_info.ppEnabledExtensionNames = &instance_extensions[0];
inst_info.enabledLayerCount = static_cast<std::uint32_t>(instance_layers.size());
inst_info.ppEnabledLayerNames = &instance_layers[0];
inst_info.pApplicationInfo = &vk_app_info;
VkInstance inst;
vk_result res = vkCreateInstance(&inst_info, &host_allocator::allocation_callbacks(), &inst);
if (!res) {
throw vk_exception(res);
}
instance = inst;
}
void Instance::create() {
std::vector<const char*> layers;
createInfo.enabledLayerCount = enabledLayers.size();
for (const auto& layer : enabledLayers) {
layers.push_back(const_cast<char*>(layer.c_str()));
}
createInfo.ppEnabledLayerNames = layers.data();
createInfo.enabledExtensionCount = enabledExtensions.size();
std::vector<const char*> extensions;
for (const auto& extension : enabledExtensions) {
extensions.push_back(const_cast<char*>(extension.c_str()));
}
createInfo.ppEnabledExtensionNames = extensions.data();
VULKAN_CHECK_RESULT(vkCreateInstance(&createInfo, nullptr, &handle), "Failed to create instance");
if (debugReportFlags) {
for (const auto& layer : enabledExtensions) {
if (layer == "VK_EXT_debug_report") {
debugCallback = std::make_unique<DebugReportCallback>(this);
debugCallback->setFlags(debugReportFlags);
debugCallback->create();
break;
}
}
}
}
VkResult VulkanBase::createInstance(bool enableValidation) {
this->enableValidation = enableValidation;
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = name.c_str();
appInfo.pEngineName = name.c_str();
appInfo.apiVersion = VK_MAKE_VERSION(1, 0, 7);
std::vector<const char*> enabledExtensions = {VK_KHR_SURFACE_EXTENSION_NAME};
enabledExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
VkInstanceCreateInfo instanceCreateInfo = {};
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pNext = NULL;
instanceCreateInfo.pApplicationInfo = &appInfo;
if (enabledExtensions.size() > 0){
if (enableValidation)
enabledExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
instanceCreateInfo.enabledExtensionCount = (uint32_t)enabledExtensions.size();
instanceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
}
if (enableValidation){
instanceCreateInfo.enabledLayerCount = vkDebug::validationLayerCount;
instanceCreateInfo.ppEnabledLayerNames = vkDebug::validationLayerNames;
}
return vkCreateInstance(&instanceCreateInfo, nullptr, &instance);
}
void createInstance() {
if (enableValidationLayers && !checkValidationLayerSupport()) {
throw std::runtime_error("validation layers requested, but not available!");
}
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Hello Triangle";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "No Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_0;
VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
auto extensions = getRequiredExtensions();
createInfo.enabledExtensionCount = extensions.size();
createInfo.ppEnabledExtensionNames = extensions.data();
if (enableValidationLayers) {
createInfo.enabledLayerCount = validationLayers.size();
createInfo.ppEnabledLayerNames = validationLayers.data();
} else {
createInfo.enabledLayerCount = 0;
}
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
throw std::runtime_error("failed to create instance!");
}
}
bool Tutorial01::CreateInstance() {
VkApplicationInfo application_info = {
VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType
nullptr, // const void *pNext
"API without Secrets: Introduction to Vulkan", // const char *pApplicationName
VK_MAKE_VERSION( 1, 0, 0 ), // uint32_t applicationVersion
"Vulkan Tutorial by Intel", // const char *pEngineName
VK_MAKE_VERSION( 1, 0, 0 ), // uint32_t engineVersion
VK_MAKE_VERSION( 1, 0, 0 ) // uint32_t apiVersion
};
VkInstanceCreateInfo instance_create_info = {
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType
nullptr, // const void* pNext
0, // VkInstanceCreateFlags flags
&application_info, // const VkApplicationInfo *pApplicationInfo
0, // uint32_t enabledLayerCount
nullptr, // const char * const *ppEnabledLayerNames
0, // uint32_t enabledExtensionCount
nullptr // const char * const *ppEnabledExtensionNames
};
if( vkCreateInstance( &instance_create_info, nullptr, &Vulkan.Instance ) != VK_SUCCESS ) {
std::cout << "Could not create Vulkan instance!" << std::endl;
return false;
}
return true;
}
VkInstance CreateVKInstance(const char* appName, const char* engineName) {
/* Create Vulkan instance */
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = appName;
appInfo.pEngineName = engineName;
appInfo.apiVersion = VK_API_VERSION_1_0;
std::vector<const char*> enabledExtensions = { VK_KHR_SURFACE_EXTENSION_NAME };
// Enable surface extensions depending on os
#if defined(_WIN32)
enabledExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif defined(__linux__)
enabledExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif
VkInstanceCreateInfo instanceCreateInfo = {};
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pNext = NULL;
instanceCreateInfo.pApplicationInfo = &appInfo;
if (enabledExtensions.size() > 0) {
instanceCreateInfo.enabledExtensionCount = (uint32_t)enabledExtensions.size();
instanceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
}
VkInstance inst;
VkResult r = vkCreateInstance(&instanceCreateInfo, nullptr, &inst);
if (r != VK_SUCCESS)
return nullptr;
return inst;
}
bool VulkanCommon::CreateInstance() {
uint32_t extensions_count = 0;
if( (vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, nullptr ) != VK_SUCCESS) ||
(extensions_count == 0) ) {
std::cout << "Error occurred during instance extensions enumeration!" << std::endl;
return false;
}
std::vector<VkExtensionProperties> available_extensions( extensions_count );
if( vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
std::cout << "Error occurred during instance extensions enumeration!" << std::endl;
return false;
}
std::vector<const char*> extensions = {
VK_KHR_SURFACE_EXTENSION_NAME,
#if defined(VK_USE_PLATFORM_WIN32_KHR)
VK_KHR_WIN32_SURFACE_EXTENSION_NAME
#elif defined(VK_USE_PLATFORM_XCB_KHR)
VK_KHR_XCB_SURFACE_EXTENSION_NAME
#elif defined(VK_USE_PLATFORM_XLIB_KHR)
VK_KHR_XLIB_SURFACE_EXTENSION_NAME
#endif
};
for( size_t i = 0; i < extensions.size(); ++i ) {
if( !CheckExtensionAvailability( extensions[i], available_extensions ) ) {
std::cout << "Could not find instance extension named \"" << extensions[i] << "\"!" << std::endl;
return false;
}
}
VkApplicationInfo application_info = {
VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType
nullptr, // const void *pNext
"API without Secrets: Introduction to Vulkan", // const char *pApplicationName
VK_MAKE_VERSION( 1, 0, 0 ), // uint32_t applicationVersion
"Vulkan Tutorial by Intel", // const char *pEngineName
VK_MAKE_VERSION( 1, 0, 0 ), // uint32_t engineVersion
VK_API_VERSION // uint32_t apiVersion
};
VkInstanceCreateInfo instance_create_info = {
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType
nullptr, // const void *pNext
0, // VkInstanceCreateFlags flags
&application_info, // const VkApplicationInfo *pApplicationInfo
0, // uint32_t enabledLayerCount
nullptr, // const char * const *ppEnabledLayerNames
static_cast<uint32_t>(extensions.size()), // uint32_t enabledExtensionCount
&extensions[0] // const char * const *ppEnabledExtensionNames
};
if( vkCreateInstance( &instance_create_info, nullptr, &Vulkan.Instance ) != VK_SUCCESS ) {
std::cout << "Could not create Vulkan instance!" << std::endl;
return false;
}
return true;
}
TEST(WrapObjects, Insert)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t familyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(familyCount, 0u);
std::unique_ptr<VkQueueFamilyProperties[]> family(new VkQueueFamilyProperties[familyCount]);
vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, family.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(familyCount, 0u);
for(uint32_t q = 0; q < familyCount; ++q)
{
if(~family[q].queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
continue;
}
float const priorities[] = {0.0f}; // Temporary required due to MSVC bug.
VkDeviceQueueCreateInfo const queueInfo[1]
{
VK::DeviceQueueCreateInfo().
queueFamilyIndex(q).
queueCount(1).
pQueuePriorities(priorities)
};
auto const deviceInfo = VK::DeviceCreateInfo().
queueCreateInfoCount(1).
pQueueCreateInfos(queueInfo);
VkDevice device;
result = vkCreateDevice(physical[p], deviceInfo, nullptr, &device);
ASSERT_EQ(result, VK_SUCCESS);
vkDestroyDevice(device, nullptr);
}
}
vkDestroyInstance(instance, nullptr);
}
void OgldevVulkanCore::CreateInstance()
{
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = m_appName.c_str();
appInfo.engineVersion = 1;
appInfo.apiVersion = VK_API_VERSION_1_0;
const char* pInstExt[] = {
#ifdef ENABLE_DEBUG_LAYERS
VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
#endif
VK_KHR_SURFACE_EXTENSION_NAME,
#ifdef _WIN32
VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
#else
VK_KHR_XCB_SURFACE_EXTENSION_NAME
#endif
};
#ifdef ENABLE_DEBUG_LAYERS
const char* pInstLayers[] = {
"VK_LAYER_LUNARG_standard_validation"
};
#endif
VkInstanceCreateInfo instInfo = {};
instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instInfo.pApplicationInfo = &appInfo;
#ifdef ENABLE_DEBUG_LAYERS
instInfo.enabledLayerCount = ARRAY_SIZE_IN_ELEMENTS(pInstLayers);
instInfo.ppEnabledLayerNames = pInstLayers;
#endif
instInfo.enabledExtensionCount = ARRAY_SIZE_IN_ELEMENTS(pInstExt);
instInfo.ppEnabledExtensionNames = pInstExt;
VkResult res = vkCreateInstance(&instInfo, NULL, &m_inst);
CHECK_VULKAN_ERROR("vkCreateInstance %d\n", res);
#ifdef ENABLE_DEBUG_LAYERS
// Get the address to the vkCreateDebugReportCallbackEXT function
my_vkCreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(vkGetInstanceProcAddr(m_inst, "vkCreateDebugReportCallbackEXT"));
// Register the debug callback
VkDebugReportCallbackCreateInfoEXT callbackCreateInfo;
callbackCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
callbackCreateInfo.pNext = NULL;
callbackCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT |
VK_DEBUG_REPORT_WARNING_BIT_EXT |
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
callbackCreateInfo.pfnCallback = &MyDebugReportCallback;
callbackCreateInfo.pUserData = NULL;
VkDebugReportCallbackEXT callback;
res = my_vkCreateDebugReportCallbackEXT(m_inst, &callbackCreateInfo, NULL, &callback);
CHECK_VULKAN_ERROR("my_vkCreateDebugReportCallbackEXT error %d\n", res);
#endif
}
TEST(CreateInstance, LayerNotPresent)
{
char const*const names[] = {"NotPresent"}; // Temporary required due to MSVC bug.
auto const info = VK::InstanceCreateInfo().
enabledLayerCount(1).
ppEnabledLayerNames(names);
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(info, VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_ERROR_LAYER_NOT_PRESENT);
// It's not necessary to destroy the instance because it will not be created successfully.
}
// Used by run_loader_tests.sh to test for layer insertion.
TEST(CreateInstance, LayerPresent)
{
char const*const names[] = {"VK_LAYER_LUNARG_parameter_validation"}; // Temporary required due to MSVC bug.
auto const info = VK::InstanceCreateInfo().
enabledLayerCount(1).
ppEnabledLayerNames(names);
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(info, VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
vkDestroyInstance(instance, nullptr);
}
bool create_instance(const char *app_name) {
uint32_t extensions_count = 0;
VK_VERIFY (vkEnumerateInstanceExtensionProperties(nullptr, &extensions_count, nullptr));
VERIFY_LOG (extensions_count > 0, LOG_TYPE, "Error occurred during instance extensions enumeration!", "");
std::vector<VkExtensionProperties> available_extensions(extensions_count);
VK_VERIFY (vkEnumerateInstanceExtensionProperties(nullptr, &extensions_count, &available_extensions[0]));
std::vector<const char *> extensions = {
VK_KHR_SURFACE_EXTENSION_NAME,
#ifdef PLATFORM_WINDOWS
VK_KHR_WIN32_SURFACE_EXTENSION_NAME
#elif PLATFORM_LINUX
VK_KHR_XCB_SURFACE_EXTENSION_NAME
#endif
};
for (size_t i = 0; i < extensions.size(); ++i) {
VERIFY_LOG(utils::check_extension(extensions[i], available_extensions), LOG_TYPE,
"Could not find instance extension named \"%s\"!", extensions[i]);
}
VkApplicationInfo application_info = {
VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType
nullptr, // const void *pNext
app_name, // const char *pApplicationName
VK_MAKE_VERSION(0, 0, 1), // uint32_t applicationVersion
"gladius", // const char *pEngineName
VK_MAKE_VERSION(0, 0, 1), // uint32_t engineVersion
VK_MAKE_VERSION(1, 0, 21) // uint32_t apiVersion
};
VkInstanceCreateInfo instance_create_info = {
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType
nullptr, // const void *pNext
0, // VkInstanceCreateFlags flags
&application_info, // const VkApplicationInfo *pApplicationInfo
0, // uint32_t enabledLayerCount
nullptr, // const char * const *ppEnabledLayerNames
static_cast<uint32_t>(extensions.size()), // uint32_t enabledExtensionCount
&extensions[0] // const char * const *ppEnabledExtensionNames
};
VK_VERIFY(vkCreateInstance(&instance_create_info, nullptr, &(vk_globals::instance)));
GET_INSTANCE_PROC_ADDR(vk_globals::instance, GetPhysicalDeviceSurfaceSupportKHR);
GET_INSTANCE_PROC_ADDR(vk_globals::instance, GetPhysicalDeviceSurfaceFormatsKHR);
return true;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Vulkan init
//
bool initVkInstance( const char* appName, const char* engineName )
{
std::cout << "\nTrying to init vulkan API\n";
std::vector<const char*> extensions;
std::vector<const char*> layers;
extensions.push_back( VK_KHR_SURFACE_EXTENSION_NAME );
extensions.push_back( VK_KHR_WIN32_SURFACE_EXTENSION_NAME );
VkApplicationInfo appInfo = {};
appInfo.apiVersion = VK_API_VERSION_1_0;
appInfo.applicationVersion = 1;
appInfo.engineVersion = 1;
appInfo.pApplicationName = appName;
appInfo.pEngineName = engineName;
appInfo.pNext = nullptr;
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
VkInstanceCreateInfo instInfo = {};
instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instInfo.pNext = nullptr;
instInfo.pApplicationInfo = &appInfo;
instInfo.flags = 0;
instInfo.enabledExtensionCount = extensions.size();
instInfo.ppEnabledExtensionNames = extensions.size() ? extensions.data() : nullptr;
instInfo.enabledLayerCount = layers.size();
instInfo.ppEnabledLayerNames = layers.size() ? layers.data() : nullptr;
VkResult res;
res = vkCreateInstance( &instInfo, nullptr, &gInstance );
if( res == VK_ERROR_INCOMPATIBLE_DRIVER )
{
std::cout << "Incompatible driver\n";
}
else if( res )
{
std::cout << "Unknown error\n";
}
else
{
std::cout << "Instance inited\n";
return true;
}
return false;
}
instance::instance() {
if (Aeon::framework::enableValidationLayers && !checkValidationLayerSupport()) {
throw Aeon::framework::exception("validation layers requested, but not available!");
}
// Setup appinfo
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Hello Triangle";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = ENGINE_NAME;
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_0;
//Setup create info
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
auto extensions = getRequiredExtensions();
createInfo.enabledExtensionCount = extensions.size();
createInfo.ppEnabledExtensionNames = extensions.data();
if (Aeon::framework::enableValidationLayers) {
createInfo.enabledLayerCount = Aeon::framework::validationLayers.size();
createInfo.ppEnabledLayerNames = Aeon::framework::validationLayers.data();
}
else {
createInfo.enabledLayerCount = 0;
}
// Create VKInstance;
if (vkCreateInstance(&createInfo, nullptr, &pdata) != VK_SUCCESS) {
throw Aeon::framework::exception("failed to create instance!");
}
// Setup debug callback
if (Aeon::framework::enableValidationLayers) {
VkDebugReportCallbackCreateInfoEXT dbgcreateInfo = {};
dbgcreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
dbgcreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
dbgcreateInfo.pfnCallback = debugCallback;
if (CreateDebugReportCallbackEXT(pdata, &dbgcreateInfo, nullptr, &callback) != VK_SUCCESS) {
throw Aeon::framework::exception("failed to set up debug callback!");
}
}
}
//Creates our vulkan instance and returns an error if it fails
VkResult gvkInitUtils::initVulkan(VkInstance * inst)
{
VkApplicationInfo appinfo = {};
appinfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appinfo.pNext = nullptr;
appinfo.pApplicationName = "TODO: CHANGE THIS";
appinfo.pEngineName = "VKEngine";
appinfo.apiVersion = VK_API_VERSION_1_0;
appinfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appinfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
std::vector<const char *> enableExtensions = { VK_KHR_SURFACE_EXTENSION_NAME};
#ifdef _WIN32
enableExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif defined(__linux__)
enableExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif
VkInstanceCreateInfo instCrInfo = {};
instCrInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instCrInfo.pApplicationInfo = &appinfo;
instCrInfo.pNext = nullptr;
#ifdef _DEBUG
std::array<const char*, 1> enabledLayers = {"VK_LAYER_LUNARG_standard_validation" };
if (!hasLayer("VK_LAYER_LUNARG_standard_validation")) {
std::cerr << "ERROR REQUIRED LAYER DOES NOT EXIST" << std::endl;
return VK_ERROR_INCOMPATIBLE_DRIVER;
}
enableExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
instCrInfo.enabledLayerCount = enabledLayers.size();
instCrInfo.ppEnabledLayerNames = enabledLayers.data();
if (!hasExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, "VK_LAYER_LUNARG_standard_validation")) {
std::cerr << "ERROR: REQUIRED EXTENSION DOES NOT EXIST" << std::endl;
return VK_ERROR_INCOMPATIBLE_DRIVER;
}
#else
instCrInfo.enabledLayerCount = 0;
instCrInfo.ppEnabledLayerNames = nullptr;
#endif
instCrInfo.flags = 0;
instCrInfo.enabledExtensionCount = enableExtensions.size();
instCrInfo.ppEnabledExtensionNames = enableExtensions.data();
return vkCreateInstance(&instCrInfo, nullptr, inst);
}
PluginRenderVulkan::PluginRenderVulkan(Engine &engine)
: RenderPlugin(engine)
, m_instanceIsValid(0)
{
log().log() << "PluginRenderVulkan start...\n";
// Filling out application description:
// sType is mandatory
m_applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
// pNext is mandatory
m_applicationInfo.pNext = nullptr;
// The name of our application
m_applicationInfo.pApplicationName = "app";
// The name of the engine (e.g: Game engine name)
m_applicationInfo.pEngineName = nullptr;
// The version of the engine
m_applicationInfo.engineVersion = 1;
// The version of Vulkan we're using for this application
m_applicationInfo.apiVersion = VK_API_VERSION_1_0;
// Filling out instance description:
// sType is mandatory
m_instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
// pNext is mandatory
m_instanceInfo.pNext = nullptr;
// flags is mandatory
m_instanceInfo.flags = 0;
// The application info structure is then passed through the instance
m_instanceInfo.pApplicationInfo = &m_applicationInfo;
// Don't enable and layer
m_instanceInfo.enabledLayerCount = 0;
m_instanceInfo.ppEnabledLayerNames = nullptr;
// Don't enable any extensions
m_instanceInfo.enabledExtensionCount = 0;
m_instanceInfo.ppEnabledExtensionNames = nullptr;
// Now create the desired instance
VkResult result = vkCreateInstance(&m_instanceInfo, nullptr, &m_instance);
if (result != VK_SUCCESS)
{
log().log() << "Failed to create instance:" << result << "\n";
}
else
{
m_instanceIsValid = 1;
}
}
void Renderer::initInstance() {
VkApplicationInfo applicationInfo{};
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
applicationInfo.apiVersion = VK_MAKE_VERSION(1, 0, 11);
applicationInfo.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
applicationInfo.pApplicationName = "Vulkan Test Application";
VkInstanceCreateInfo instanceCreateInfo{};
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pApplicationInfo = &applicationInfo;
instanceCreateInfo.enabledLayerCount = mInstanceLayerList.size();
instanceCreateInfo.ppEnabledLayerNames = mInstanceLayerList.data();
instanceCreateInfo.enabledExtensionCount = mInstanceExtensionList.size();
instanceCreateInfo.ppEnabledExtensionNames = mInstanceExtensionList.data();
instanceCreateInfo.pNext = &mDebugCallbackCreateInfo;
errorCheck(vkCreateInstance(&instanceCreateInfo, nullptr, &mInstance));
}
VkInstance VulkanContext::CreateVulkanInstance(WindowSystemType wstype, bool enable_debug_report,
bool enable_validation_layer)
{
ExtensionList enabled_extensions;
if (!SelectInstanceExtensions(&enabled_extensions, wstype, enable_debug_report))
return VK_NULL_HANDLE;
VkApplicationInfo app_info = {};
app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app_info.pNext = nullptr;
app_info.pApplicationName = "Dolphin Emulator";
app_info.applicationVersion = VK_MAKE_VERSION(5, 0, 0);
app_info.pEngineName = "Dolphin Emulator";
app_info.engineVersion = VK_MAKE_VERSION(5, 0, 0);
app_info.apiVersion = VK_MAKE_VERSION(1, 0, 0);
VkInstanceCreateInfo instance_create_info = {};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pNext = nullptr;
instance_create_info.flags = 0;
instance_create_info.pApplicationInfo = &app_info;
instance_create_info.enabledExtensionCount = static_cast<uint32_t>(enabled_extensions.size());
instance_create_info.ppEnabledExtensionNames = enabled_extensions.data();
instance_create_info.enabledLayerCount = 0;
instance_create_info.ppEnabledLayerNames = nullptr;
// Enable debug layer on debug builds
if (enable_validation_layer)
{
static const char* layer_names[] = {"VK_LAYER_LUNARG_standard_validation"};
instance_create_info.enabledLayerCount = 1;
instance_create_info.ppEnabledLayerNames = layer_names;
}
VkInstance instance;
VkResult res = vkCreateInstance(&instance_create_info, nullptr, &instance);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateInstance failed: ");
return nullptr;
}
return instance;
}
void Renderer::_InitInstance()
{
VkApplicationInfo applicationInfo;
VkInstanceCreateInfo instanceInfo;
// Filling out application description:
// sType is mandatory
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
// pNext is mandatory
applicationInfo.pNext = NULL;
// The name of our application
applicationInfo.pApplicationName = "Tutorial 1";
// The name of the engine (e.g: Game engine name)
applicationInfo.pEngineName = "GPU Chameleon";
// The version of the engine
applicationInfo.engineVersion = 1;
// The version of Vulkan we're using for this application
applicationInfo.apiVersion = VK_API_VERSION_1_0;
// Filling out instance description:
// sType is mandatory
instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
// pNext is mandatory
instanceInfo.pNext = NULL;
// flags is mandatory
instanceInfo.flags = 0;
// The application info structure is then passed through the instance
instanceInfo.pApplicationInfo = &applicationInfo;
// Don't enable and layer
instanceInfo.enabledLayerCount = 0;
instanceInfo.ppEnabledLayerNames = NULL;
// Don't enable any extensions
instanceInfo.enabledExtensionCount = 0;
instanceInfo.ppEnabledExtensionNames = NULL;
// Now create the desired instance
VkResult result = vkCreateInstance(&instanceInfo, NULL, &instance);
if (result != VK_SUCCESS) {
fprintf(stderr, "Failed to create instance: %d\n", result);
abort();
}
}
bool VkContext::CreateInstance(const char* name) {
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pNext = nullptr;
appInfo.pApplicationName = name;
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Voxl Engine";
appInfo.engineVersion = VK_MAKE_VERSION(VOXL_VERSION_MAJOR, VOXL_VERSION_MINOR, VOXL_VERSION_PATCH);
appInfo.apiVersion = VK_API_VERSION_1_0;
std::vector<const char *> instanceExtensions;
std::vector<const char *> instanceLayers;
#ifdef VOXL_DEBUG
// Add debug report extension
instanceExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
// Add validation layers
instanceLayers.push_back("VK_LAYER_LUNARG_standard_validation");
#endif
// Add GLFW extensions
u32 glfwExtensionCount = 0;
const char **glfwExtensions =
glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
for (u32 i = 0; i < glfwExtensionCount; i++) {
instanceExtensions.push_back(glfwExtensions[i]);
}
VkInstanceCreateInfo instanceInfo = {};
instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceInfo.pNext = nullptr;
instanceInfo.flags = 0;
instanceInfo.pApplicationInfo = &appInfo;
instanceInfo.enabledExtensionCount = (u32)instanceExtensions.size();
instanceInfo.ppEnabledExtensionNames = instanceExtensions.data();
instanceInfo.enabledLayerCount = (u32)instanceLayers.size();
instanceInfo.ppEnabledLayerNames = instanceLayers.data();
CheckVkResult(vkCreateInstance(&instanceInfo, nullptr, &instance));
return true;
}
void Renderer::_InitInstance()
{
VkApplicationInfo application_info {};
application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
application_info.apiVersion = VK_MAKE_VERSION( 1, 0, 2 ); // 1.0.2 should work on all vulkan enabled drivers.
application_info.applicationVersion = VK_MAKE_VERSION( 0, 1, 0 );
application_info.pApplicationName = "Vulkan API Tutorial Series";
VkInstanceCreateInfo instance_create_info {};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pApplicationInfo = &application_info;
instance_create_info.enabledLayerCount = _instance_layers.size();
instance_create_info.ppEnabledLayerNames = _instance_layers.data();
instance_create_info.enabledExtensionCount = _instance_extensions.size();
instance_create_info.ppEnabledExtensionNames = _instance_extensions.data();
instance_create_info.pNext = &_debug_callback_create_info;
ErrorCheck( vkCreateInstance( &instance_create_info, nullptr, &_instance ) );
}
VkResult VulkanExampleBase::createInstance(bool enableValidation)
{
this->enableValidation = enableValidation;
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = name.c_str();
appInfo.pEngineName = name.c_str();
// Temporary workaround for drivers not supporting SDK 1.0.3 upon launch
// todo : Use VK_API_VERSION
appInfo.apiVersion = VK_MAKE_VERSION(1, 0, 2);
std::vector<const char*> enabledExtensions = { VK_KHR_SURFACE_EXTENSION_NAME };
// Enable surface extensions depending on os
#if defined(_WIN32)
enabledExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif defined(__ANDROID__)
enabledExtensions.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
#elif defined(__linux__)
enabledExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif
VkInstanceCreateInfo instanceCreateInfo = {};
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pNext = NULL;
instanceCreateInfo.pApplicationInfo = &appInfo;
if (enabledExtensions.size() > 0)
{
if (enableValidation)
{
enabledExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
}
instanceCreateInfo.enabledExtensionCount = (uint32_t)enabledExtensions.size();
instanceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
}
if (enableValidation)
{
instanceCreateInfo.enabledLayerCount = vkDebug::validationLayerCount;
instanceCreateInfo.ppEnabledLayerNames = vkDebug::validationLayerNames;
}
return vkCreateInstance(&instanceCreateInfo, nullptr, &instance);
}
// Instances
void Renderer::_InitInstance() {
// Application info
VkApplicationInfo application_info {};
application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
application_info.apiVersion = VK_MAKE_VERSION(1, 0, 13);
application_info.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
application_info.pApplicationName = "Vulkan Testing";
// Instance create info
VkInstanceCreateInfo instance_create_info{};
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instance_create_info.pApplicationInfo = &application_info;
instance_create_info.enabledLayerCount = (uint32_t) _instance_layer_list.size();
instance_create_info.ppEnabledLayerNames = _instance_layer_list.data();
instance_create_info.enabledExtensionCount = (uint32_t) _instance_extension_list.size();
instance_create_info.ppEnabledExtensionNames = _instance_extension_list.data();
instance_create_info.pNext = &_debug_callback_create_info;
ErrorCheck(vkCreateInstance(&instance_create_info, nullptr, &_instance));
}
TEST(LX435, InstanceCreateInfoConst)
{
VkInstanceCreateInfo const info =
{
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
nullptr,
0,
nullptr,
0,
nullptr,
0,
nullptr
};
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(&info, VK_NULL_HANDLE, &instance);
EXPECT_EQ(result, VK_SUCCESS);
vkDestroyInstance(instance, nullptr);
}
VulkanInstance::VulkanInstance(const char* applicationName,
unsigned int applicationVersion,
bool enableValidation)
{
VulkanLayers vulkanLayer;
VulkanExtensions vulkanExtensions;
vulkanExtensions.require("VK_KHR_win32_surface");
std::vector<const char*> layers = vulkanLayer.getInstanceLayers();
std::vector<const char*> extensions = vulkanExtensions.getRequiredInstanceExtensions();
// Set the data for this application.
VkApplicationInfo applicationInfo;
applicationInfo.apiVersion = 0; // Must be 0, otherwise must be version that application supports.
applicationInfo.applicationVersion = applicationVersion; // The name and version supplied by our user.
applicationInfo.pApplicationName = applicationName;
applicationInfo.engineVersion = engineVersion; // A preliminary name and version for our graphics engine.
applicationInfo.pEngineName = engineName;
applicationInfo.pNext = nullptr; // pNext must be NULL.
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; // sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO.
// Check that conversions are still correct.
assert(extensions.size() == static_cast<uint32_t>(extensions.size()));
VkInstanceCreateInfo createInfo;
createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
createInfo.enabledLayerCount = static_cast<uint32_t>(layers.size());
createInfo.flags = 0; // flags must be 0.
createInfo.pApplicationInfo = nullptr; // &applicationInfo;
createInfo.pNext = nullptr; // pNext must be NULL.
createInfo.ppEnabledExtensionNames = (extensions.size() > 0) ? extensions.data() : nullptr;
createInfo.ppEnabledLayerNames = (layers.size() > 0) ? layers.data() : nullptr;
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; // sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO.
// Create the instance.
VKR_VK_VERIFY(Fatal, vkCreateInstance(&createInfo,
nullptr,
&m_instance));
}
void createInstance()
{
// Get the required vulkan extensions
auto extensions = std::move(getRequiredExtensions());
// Fetch the validation layers we watch
if(enableValidationLayers && !checkValidationLayerSupport()) {
throw std::runtime_error("Requested validation layers unavailable");
}
// Setup some simple application information for Vulkan
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = TITLE;
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Derpgin";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_0;
// Setup the instance information
VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
createInfo.enabledExtensionCount = extensions.size();
createInfo.ppEnabledExtensionNames = extensions.data();
createInfo.enabledLayerCount = 0;
if(enableValidationLayers) {
createInfo.enabledLayerCount = validationLayers.size();
createInfo.ppEnabledLayerNames = validationLayers.data();
} else {
createInfo.enabledLayerCount = 0;
}
// Create the vulkan instance
if(vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
throw std::runtime_error("Failed to create Vulkan instance");
}
}
bool VKAppInstance::Initialize(std::string title)
{
VkResult res = VK_SUCCESS;
if(!CheckInstanceExtensions())
return false;
VkApplicationInfo info;
info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
info.pNext = nullptr;
info.pApplicationName = title.c_str();
info.applicationVersion = 0;
info.pEngineName = "VulkanExamples";
info.engineVersion = 0;
info.apiVersion = VK_MAKE_VERSION(1, 0, 11);
for(auto layers : m_instanceLayerCollection)
{
m_enabledLayerNames = layers;
VkInstanceCreateInfo cInfo;
cInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
cInfo.pNext = nullptr;
cInfo.flags = 0;
cInfo.pApplicationInfo = &info;
cInfo.enabledLayerCount = static_cast<uint32_t>(layers.size());
cInfo.ppEnabledLayerNames = &layers[0];
cInfo.enabledExtensionCount = m_enabledExtNames.size();
cInfo.ppEnabledExtensionNames = &m_enabledExtNames[0];
res = vkCreateInstance(&cInfo, nullptr, &m_instance);
if(res == VK_SUCCESS)
break;
else
std::cerr << "Failed to create Vulkan instance." << std::endl;
}
return true;
}
TEST(EnumerateDeviceExtensionProperties, DeviceExtensionEnumerated)
{
VkInstance instance = VK_NULL_HANDLE;
VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), VK_NULL_HANDLE, &instance);
ASSERT_EQ(result, VK_SUCCESS);
uint32_t physicalCount = 0;
result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_GT(physicalCount, 0u);
for(uint32_t p = 0; p < physicalCount; ++p)
{
uint32_t count = 0u;
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, nullptr);
ASSERT_EQ(result, VK_SUCCESS);
std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]);
result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, properties.get());
ASSERT_EQ(result, VK_SUCCESS);
ASSERT_NE(std::find_if(
&properties[0],
&properties[count],
[](VkExtensionProperties const& properties)
{
return strcmp(properties.extensionName, "VK_KHR_swapchain") == 0;
}),
&properties[count]);
}
vkDestroyInstance(instance, nullptr);
}
VkResult Instance::create()
{
const char* extensionNames[] = { VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME };
VkApplicationInfo applicationInfo = {};
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
applicationInfo.pApplicationName = "test_vk";
applicationInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
applicationInfo.pEngineName = "test_vk";
applicationInfo.engineVersion = VK_MAKE_VERSION(0, 9, 0);
applicationInfo.apiVersion = VK_API_VERSION;
VkInstanceCreateInfo instanceCreateInfo = {};
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.flags = 0;
instanceCreateInfo.pApplicationInfo = &applicationInfo;
instanceCreateInfo.enabledLayerCount = 0;
instanceCreateInfo.ppEnabledLayerNames = nullptr;
instanceCreateInfo.enabledExtensionCount = 2;
instanceCreateInfo.ppEnabledExtensionNames = extensionNames;
return vkCreateInstance(&instanceCreateInfo, nullptr, &m_instance);
}
