Dear Doug,
Thank you for the information that the 2015 libraries work with VC++ 2017. It will take me some time to work through the items that you have suggested.
Yesterday I added the code from Tutorial [023] . After each new line I have included the comment //023. What I find is that glfwCreateWindowSurface is undefined. Perhaps this is useful clue. Let me try to add the complete code as you suggested.
//HELLO VULKAN X86//
#include <iostream>
#include <vector>
//#define GLFW_INCLUDE_VULKAN //BUILD FAILS
#include<GLFW\glfw3.h>
#define VK_USE_PLATFORM_WIN32_KHR "VK_KHR_Win32_surface"
//#define GLFW_VULKAN_STATIC
#include "vulkan\vulkan.h" //REQUIRED TO BUILD
void ASSERT_VULKAN(VkResult value)
{
if (value != VK_SUCCESS) { std::cout << "ASSERT FAILED\n" << value; }
}
void printStats(VkPhysicalDevice &device)
{
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(device, &properties);
uint32_t apiVer = properties.apiVersion;
std::cout << "\n HELLO VULKAN X86 PRINT STATS\n\n";
std::cout << " Name: " << properties.deviceName << "\n";
std::cout << " API Version: " << properties.apiVersion << "\n";
std::cout << " Driver Version: " << properties.driverVersion << "\n";
std::cout << " Device ID: " << properties.deviceID << "\n";
std::cout << " Device Type: " << properties.deviceType << "\n";
std::cout << " Discrete Queue Priorities: " << properties.limits.discreteQueuePriorities << "\n";
VkPhysicalDeviceFeatures features;
vkGetPhysicalDeviceFeatures(device, &features);
std::cout << " Geometry Shader : " << features.geometryShader << "\n";
std::cout << " Tessellation Shader : " << features.tessellationShader << "\n";
VkPhysicalDeviceMemoryProperties memProps;
uint32_t numberofQueueFamilies = 0;
uint32_t queueCount = 0;
vkGetPhysicalDeviceMemoryProperties(device, &memProps);
vkGetPhysicalDeviceQueueFamilyProperties(device, &numberofQueueFamilies, nullptr);
VkQueueFamilyProperties *familyProperties = new VkQueueFamilyProperties[numberofQueueFamilies]; // BETTER USE STD::VECTOR
vkGetPhysicalDeviceQueueFamilyProperties(device, &numberofQueueFamilies, familyProperties);
std::cout << " Number of Queue Families: " << numberofQueueFamilies << "\n";
for (uint32_t i = 0; i < numberofQueueFamilies; i++)
{
std::cout << "\n Queue Family # " << i << " \n";
std::cout << " VK_QUEUE_GRAPHICS_BIT: " << ((familyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) << "\n";
std::cout << " VK_QUEUE_COMPUTE_BIT: " << ((familyProperties[i].queueFlags & VK_QUEUE_COMPUTE_BIT) != 0) << "\n";
std::cout << " VK_QUEUE_TRANSFER_BIT: " << ((familyProperties[i].queueFlags & VK_QUEUE_TRANSFER_BIT) != 0) << "\n";
std::cout << " VK_QUEUE_SPARSE_BINDING_BIT: " << ((familyProperties[i].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) != 0) << "\n";
std::cout << " Queue Count: " << familyProperties[i].queueCount << "\n";
std::cout << " Timestamp Valid Bits: " << familyProperties[i].timestampValidBits << "\n";
uint32_t width = familyProperties[i].minImageTransferGranularity.width;
uint32_t height = familyProperties[i].minImageTransferGranularity.height;
uint32_t depth = familyProperties[i].minImageTransferGranularity.depth;
std::cout << " Min Image timestamp Granularity: " << width << ", " << height << ", " << depth << "\n";
}
delete[] familyProperties;
}
VkApplicationInfo appInfo;
VkInstance instance;
VkSurfaceKHR surface; //023
VkDevice device;
GLFWwindow *window;
void startGlfw()
{
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
window = glfwCreateWindow(1000, 800, " HELLO VULKAN X86 ", nullptr, nullptr);
}
//int main(int argc, char** argv)
void startVulkan()
{
//APPLICATION INFO//
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pNext = NULL;
appInfo.pApplicationName = "VULKAN TUTORIAL";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "JOHN'S MACHINE";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_0;
uint32_t numberofLayers = 0;
vkEnumerateInstanceLayerProperties(&numberofLayers, nullptr);
VkLayerProperties *layers = new VkLayerProperties[numberofLayers];
vkEnumerateInstanceLayerProperties(&numberofLayers, layers);
std::cout << "\n HELLO VULKAN X86 \n\n DEVICE PROPERTIES\n";
std::cout << "\n Number of Instance Layers: " << numberofLayers << "\n";
for (uint32_t i = 0; i < numberofLayers; i++)
{
std::cout << " Name: " << layers[i].layerName << "\n";
std::cout << " Spec Version: " << layers[i].specVersion << "\n";
std::cout << " Implementation Version: " << layers[i].implementationVersion << "\n";
std::cout << " Description: " << layers[i].description << "\n\n";
}
uint32_t numberofExtensions = 0;
vkEnumerateInstanceExtensionProperties(nullptr, &numberofExtensions, nullptr);
VkExtensionProperties *extensions = new VkExtensionProperties[numberofExtensions];
vkEnumerateInstanceExtensionProperties(nullptr, &numberofExtensions, extensions);
std::cout << "\n Number of Extensions: " << numberofExtensions << "\n";
for (uint32_t i = 0; i < numberofExtensions; i++)
{
std::cout << " Name: " << extensions[i].extensionName << "\n";
std::cout << " Spec Version: " << extensions[i].specVersion << "\n";
}
const std::vector<const char*> validationLayers = { "VK_LAYER_LUNARG_standard_validation" };
const std::vector<const char*> usedExtensions = { "VK_KHR_surface", VK_KHR_WIN32_SURFACE_EXTENSION_NAME };
uint32_t numberofGlfwExtensions = 0;//023
auto glfwExtensions = glfwGetRequiredInstanceExtensions(&numberofGlfwExtensions);//023
//INSTANCE INFO//
VkInstanceCreateInfo instanceInfo;
instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceInfo.pNext = nullptr;
instanceInfo.flags = 0;
instanceInfo.pApplicationInfo = &appInfo;
instanceInfo.enabledLayerCount = 0;
instanceInfo.ppEnabledLayerNames = nullptr;
instanceInfo.enabledExtensionCount = numberofGlfwExtensions;
instanceInfo.ppEnabledExtensionNames = usedExtensions.data();
//INSTANCE CREATION//
VkResult result = vkCreateInstance(&instanceInfo, nullptr, &instance);// THIS THROWS EXCEPTION FOR LAYER COUNT >0
ASSERT_VULKAN(result);
result = glfwCreateWindowSurface(instance, window, nullptr, &surface); //023 GLFWCREATEWINDOWSURFACE UNDEFINED !
//ASSERT_VULKAN(result); //023
//SURFACE INFO//
VkWin32SurfaceCreateInfoKHR surfaceCreateInfo;
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
surfaceCreateInfo.pNext = nullptr;
surfaceCreateInfo.flags = 0;
surfaceCreateInfo.hinstance = nullptr;
surfaceCreateInfo.hwnd = nullptr;
ASSERT_VULKAN(result);
//UNSURE CONCERNING ORDER OF SURFACE AND PROCADDR HERE//
//VkSurfaceKHR surface;
result = vkCreateWin32SurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
ASSERT_VULKAN(result);
vkGetInstanceProcAddr(instance, "");
uint32_t numberofPhysicalDevices = 0;
result = vkEnumeratePhysicalDevices(instance, &numberofPhysicalDevices, nullptr);
ASSERT_VULKAN(result);
//VkPhysicalDevice *physicalDevices = new VkPhysicalDevice[numberofPhysicalDevices];
std::vector<VkPhysicalDevice> physicalDevices;
physicalDevices.resize(numberofPhysicalDevices);
result = vkEnumeratePhysicalDevices(instance, &numberofPhysicalDevices, physicalDevices.data());
ASSERT_VULKAN(result);
for (uint32_t i = 0; i < numberofPhysicalDevices; i++)
{
printStats(physicalDevices[i]);
}
//QUEUE INFO//
float queuePriorities[] = { 1.0f, 1.0f, 1.0f, 1.0f };
VkDeviceQueueCreateInfo deviceQueueCreateInfo;
deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceQueueCreateInfo.pNext = nullptr;
deviceQueueCreateInfo.flags = 0;
deviceQueueCreateInfo.queueFamilyIndex = 0; // TO DO SELECT CORRECT FAMILY INDEX
deviceQueueCreateInfo.queueCount = 4; // TO DO CHECK IF THIS IS A VALID NUMBER
deviceQueueCreateInfo.pQueuePriorities = nullptr; // TO DO CHECK IF THIS IS A VALID NUMBER
//PHYSICAL DEVICE//
VkPhysicalDeviceFeatures usedFeatures = {};
VkDeviceCreateInfo deviceCreateInfo;
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.pNext = nullptr;
deviceCreateInfo.flags = 0;
deviceCreateInfo.queueCreateInfoCount = 1;
deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
deviceCreateInfo.enabledLayerCount = 0;
deviceCreateInfo.ppEnabledLayerNames = nullptr;
deviceCreateInfo.enabledExtensionCount = 0;
deviceCreateInfo.ppEnabledExtensionNames = nullptr;
deviceCreateInfo.pEnabledFeatures = &usedFeatures;
result = vkCreateDevice(physicalDevices[0], &deviceCreateInfo, nullptr, &device);
ASSERT_VULKAN(result);
VkQueue queue;
vkGetDeviceQueue(device, 0, 0, &queue);
vkDeviceWaitIdle(device);
vkDestroyDevice(device, nullptr);
vkDestroySurfaceKHR(instance, surface, nullptr);
vkDestroyInstance(instance, nullptr);
delete[] layers;
delete[] extensions;
}
void mainLoop()
{
while(true)// (!glfwWindowShouldClose(window)) //THIS THROWS EXCEPTION (true) WINDOW PERSISTS BUT CAN'T BE CLOSED
{
glfwPollEvents();
}
}
void shutdownVulkan()
{
vkDeviceWaitIdle(device);
vkDestroyDevice(device, nullptr);
vkDestroySurfaceKHR(instance, surface, nullptr);
vkDestroyInstance(instance, nullptr);
}
void shutdownGlfw()
{
glfwDestroyWindow(window);
}
int main(int argc, char** argv)
{
startGlfw();
startVulkan();
mainLoop();
shutdownVulkan();
shutdownGlfw();
//getchar();
return 0;
Although the first two includes are not showing here they are present in my code.
yours sincerely
John